
C:\Temp\arduino_build_796202\bme280test.ino.elf:     file format elf32-avr


Disassembly of section .text:

00000000 <__vectors>:
       0:	0c 94 a9 00 	jmp	0x152	; 0x152 <__ctors_end>
       4:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
       8:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
       c:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      10:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      14:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      18:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      1c:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      20:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      24:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      28:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      2c:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      30:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      34:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      38:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      3c:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      40:	0c 94 58 0a 	jmp	0x14b0	; 0x14b0 <__vector_16>
      44:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      48:	0c 94 26 0a 	jmp	0x144c	; 0x144c <__vector_18>
      4c:	0c 94 00 0a 	jmp	0x1400	; 0x1400 <__vector_19>
      50:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      54:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      58:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      5c:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      60:	0c 94 a2 0a 	jmp	0x1544	; 0x1544 <__vector_24>
      64:	0c 94 d1 00 	jmp	0x1a2	; 0x1a2 <__bad_interrupt>
      68:	07 63       	ori	r16, 0x37	; 55
      6a:	42 36       	cpi	r20, 0x62	; 98
      6c:	b7 9b       	sbis	0x16, 7	; 22
      6e:	d8 a7       	std	Y+40, r29	; 0x28
      70:	1a 39       	cpi	r17, 0x9A	; 154
      72:	68 56       	subi	r22, 0x68	; 104
      74:	18 ae       	std	Y+56, r1	; 0x38
      76:	ba ab       	std	Y+50, r27	; 0x32
      78:	55 8c       	ldd	r5, Z+29	; 0x1d
      7a:	1d 3c       	cpi	r17, 0xCD	; 205
      7c:	b7 cc       	rjmp	.-1682   	; 0xfffff9ec <__eeprom_end+0xff7ef9ec>
      7e:	57 63       	ori	r21, 0x37	; 55
      80:	bd 6d       	ori	r27, 0xDD	; 221
      82:	ed fd       	.word	0xfded	; ????
      84:	75 3e       	cpi	r23, 0xE5	; 229
      86:	f6 17       	cp	r31, r22
      88:	72 31       	cpi	r23, 0x12	; 18
      8a:	bf 00       	.word	0x00bf	; ????
      8c:	00 00       	nop
      8e:	80 3f       	cpi	r24, 0xF0	; 240
      90:	08 00       	.word	0x0008	; ????
      92:	00 00       	nop
      94:	be 92       	st	-X, r11
      96:	24 49       	sbci	r18, 0x94	; 148
      98:	12 3e       	cpi	r17, 0xE2	; 226
      9a:	ab aa       	std	Y+51, r10	; 0x33
      9c:	aa 2a       	or	r10, r26
      9e:	be cd       	rjmp	.-1156   	; 0xfffffc1c <__eeprom_end+0xff7efc1c>
      a0:	cc cc       	rjmp	.-1640   	; 0xfffffa3a <__eeprom_end+0xff7efa3a>
      a2:	4c 3e       	cpi	r20, 0xEC	; 236
      a4:	00 00       	nop
      a6:	00 80       	ld	r0, Z
      a8:	be ab       	std	Y+54, r27	; 0x36
      aa:	aa aa       	std	Y+50, r10	; 0x32
      ac:	aa 3e       	cpi	r26, 0xEA	; 234
      ae:	00 00       	nop
      b0:	00 00       	nop
      b2:	bf 00       	.word	0x00bf	; ????
      b4:	00 00       	nop
      b6:	80 3f       	cpi	r24, 0xF0	; 240
      b8:	00 00       	nop
      ba:	00 00       	nop
      bc:	00 08       	sbc	r0, r0
      be:	41 78       	andi	r20, 0x81	; 129
      c0:	d3 bb       	out	0x13, r29	; 19
      c2:	43 87       	std	Z+11, r20	; 0x0b
      c4:	d1 13       	cpse	r29, r17
      c6:	3d 19       	sub	r19, r13
      c8:	0e 3c       	cpi	r16, 0xCE	; 206
      ca:	c3 bd       	out	0x23, r28	; 35
      cc:	42 82       	std	Z+2, r4	; 0x02
      ce:	ad 2b       	or	r26, r29
      d0:	3e 68       	ori	r19, 0x8E	; 142
      d2:	ec 82       	std	Y+4, r14	; 0x04
      d4:	76 be       	out	0x36, r7	; 54
      d6:	d9 8f       	std	Y+25, r29	; 0x19
      d8:	e1 a9       	ldd	r30, Z+49	; 0x31
      da:	3e 4c       	sbci	r19, 0xCE	; 206
      dc:	80 ef       	ldi	r24, 0xF0	; 240
      de:	ff be       	out	0x3f, r15	; 63
      e0:	01 c4       	rjmp	.+2050   	; 0x8e4 <_ZN15Adafruit_BME2806write8Ehh.constprop.40+0x76>
      e2:	ff 7f       	andi	r31, 0xFF	; 255
      e4:	3f 00       	.word	0x003f	; ????
      e6:	00 00       	nop
	...

000000ea <__trampolines_end>:
      ea:	00 00       	nop
      ec:	00 00       	nop
      ee:	25 00       	.word	0x0025	; ????
      f0:	28 00       	.word	0x0028	; ????
      f2:	2b 00       	.word	0x002b	; ????

000000f4 <port_to_mode_PGM>:
      f4:	00 00 00 00 24 00 27 00 2a 00                       ....$.'.*.

000000fe <_ZZ5setupE3__c>:
      fe:	42 4d 45 32 38 30 20 74 65 73 74 00                 BME280 test.

0000010a <port_to_input_PGM>:
     10a:	00 00 00 00 23 00 26 00 29 00                       ....#.&.).

00000114 <digital_pin_to_port_PGM>:
     114:	04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03     ................
     124:	03 03 03 03                                         ....

00000128 <digital_pin_to_bit_mask_PGM>:
     128:	01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02     ..... @...... ..
     138:	04 08 10 20                                         ... 

0000013c <digital_pin_to_timer_PGM>:
     13c:	00 00 00 08 00 02 01 00 00 03 04 07 00 00 00 00     ................
     14c:	00 00 00 00                                         ....

00000150 <__ctors_start>:
     150:	c1 0b       	sbc	r28, r17

00000152 <__ctors_end>:
     152:	11 24       	eor	r1, r1
     154:	1f be       	out	0x3f, r1	; 63
     156:	cf ef       	ldi	r28, 0xFF	; 255
     158:	d8 e0       	ldi	r29, 0x08	; 8
     15a:	de bf       	out	0x3e, r29	; 62
     15c:	cd bf       	out	0x3d, r28	; 61

0000015e <__do_copy_data>:
     15e:	11 e0       	ldi	r17, 0x01	; 1
     160:	a0 e0       	ldi	r26, 0x00	; 0
     162:	b1 e0       	ldi	r27, 0x01	; 1
     164:	ec ed       	ldi	r30, 0xDC	; 220
     166:	fa e2       	ldi	r31, 0x2A	; 42
     168:	02 c0       	rjmp	.+4      	; 0x16e <__do_copy_data+0x10>
     16a:	05 90       	lpm	r0, Z+
     16c:	0d 92       	st	X+, r0
     16e:	a4 3c       	cpi	r26, 0xC4	; 196
     170:	b1 07       	cpc	r27, r17
     172:	d9 f7       	brne	.-10     	; 0x16a <__do_copy_data+0xc>

00000174 <__do_clear_bss>:
     174:	23 e0       	ldi	r18, 0x03	; 3
     176:	a4 ec       	ldi	r26, 0xC4	; 196
     178:	b1 e0       	ldi	r27, 0x01	; 1
     17a:	01 c0       	rjmp	.+2      	; 0x17e <.do_clear_bss_start>

0000017c <.do_clear_bss_loop>:
     17c:	1d 92       	st	X+, r1

0000017e <.do_clear_bss_start>:
     17e:	a2 36       	cpi	r26, 0x62	; 98
     180:	b2 07       	cpc	r27, r18
     182:	e1 f7       	brne	.-8      	; 0x17c <.do_clear_bss_loop>

00000184 <__do_global_ctors>:
     184:	10 e0       	ldi	r17, 0x00	; 0
     186:	c9 ea       	ldi	r28, 0xA9	; 169
     188:	d0 e0       	ldi	r29, 0x00	; 0
     18a:	04 c0       	rjmp	.+8      	; 0x194 <__do_global_ctors+0x10>
     18c:	21 97       	sbiw	r28, 0x01	; 1
     18e:	fe 01       	movw	r30, r28
     190:	0e 94 57 15 	call	0x2aae	; 0x2aae <__tablejump2__>
     194:	c8 3a       	cpi	r28, 0xA8	; 168
     196:	d1 07       	cpc	r29, r17
     198:	c9 f7       	brne	.-14     	; 0x18c <__do_global_ctors+0x8>
     19a:	0e 94 01 0c 	call	0x1802	; 0x1802 <main>
     19e:	0c 94 6c 15 	jmp	0x2ad8	; 0x2ad8 <_exit>

000001a2 <__bad_interrupt>:
     1a2:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>

000001a6 <_ZN8SPIClass16beginTransactionE11SPISettings.constprop.46>:
      digitalWrite(SPI_TRANSACTION_MISMATCH_LED, HIGH);
    }
    inTransactionFlag = 1;
    #endif

    SPCR = settings.spcr;
     1a6:	8c bd       	out	0x2c, r24	; 44
    SPSR = settings.spsr;
     1a8:	9d bd       	out	0x2d, r25	; 45
  }
     1aa:	08 95       	ret

000001ac <_ZN7TwoWire16onRequestServiceEv>:
  // !!! this will kill any pending pre-master sendTo() activity
  txBufferIndex = 0;
  txBufferLength = 0;
  // alert user program
  user_onRequest();
}
     1ac:	08 95       	ret

000001ae <_ZN7TwoWire16onReceiveServiceEPhi>:
  // set rx iterator vars
  rxBufferIndex = 0;
  rxBufferLength = numBytes;
  // alert user program
  user_onReceive(numBytes);
}
     1ae:	08 95       	ret

000001b0 <_ZN5Print5writeEPKhj>:

// Public Methods //////////////////////////////////////////////////////////////

/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
     1b0:	af 92       	push	r10
     1b2:	bf 92       	push	r11
     1b4:	cf 92       	push	r12
     1b6:	df 92       	push	r13
     1b8:	ef 92       	push	r14
     1ba:	ff 92       	push	r15
     1bc:	0f 93       	push	r16
     1be:	1f 93       	push	r17
     1c0:	cf 93       	push	r28
     1c2:	df 93       	push	r29
     1c4:	6c 01       	movw	r12, r24
     1c6:	7b 01       	movw	r14, r22
     1c8:	8b 01       	movw	r16, r22
     1ca:	04 0f       	add	r16, r20
     1cc:	15 1f       	adc	r17, r21
     1ce:	eb 01       	movw	r28, r22
     1d0:	5e 01       	movw	r10, r28
     1d2:	ae 18       	sub	r10, r14
     1d4:	bf 08       	sbc	r11, r15
  size_t n = 0;
  while (size--) {
     1d6:	c0 17       	cp	r28, r16
     1d8:	d1 07       	cpc	r29, r17
     1da:	59 f0       	breq	.+22     	; 0x1f2 <_ZN5Print5writeEPKhj+0x42>
    if (write(*buffer++)) n++;
     1dc:	69 91       	ld	r22, Y+
     1de:	d6 01       	movw	r26, r12
     1e0:	ed 91       	ld	r30, X+
     1e2:	fc 91       	ld	r31, X
     1e4:	01 90       	ld	r0, Z+
     1e6:	f0 81       	ld	r31, Z
     1e8:	e0 2d       	mov	r30, r0
     1ea:	c6 01       	movw	r24, r12
     1ec:	09 95       	icall
     1ee:	89 2b       	or	r24, r25
     1f0:	79 f7       	brne	.-34     	; 0x1d0 <_ZN5Print5writeEPKhj+0x20>
    else break;
  }
  return n;
}
     1f2:	c5 01       	movw	r24, r10
     1f4:	df 91       	pop	r29
     1f6:	cf 91       	pop	r28
     1f8:	1f 91       	pop	r17
     1fa:	0f 91       	pop	r16
     1fc:	ff 90       	pop	r15
     1fe:	ef 90       	pop	r14
     200:	df 90       	pop	r13
     202:	cf 90       	pop	r12
     204:	bf 90       	pop	r11
     206:	af 90       	pop	r10
     208:	08 95       	ret

0000020a <_ZN14HardwareSerial17availableForWriteEv>:
{
  tx_buffer_index_t head;
  tx_buffer_index_t tail;

  TX_BUFFER_ATOMIC {
    head = _tx_buffer_head;
     20a:	fc 01       	movw	r30, r24
     20c:	53 8d       	ldd	r21, Z+27	; 0x1b
    tail = _tx_buffer_tail;
     20e:	44 8d       	ldd	r20, Z+28	; 0x1c
     210:	25 2f       	mov	r18, r21
     212:	30 e0       	ldi	r19, 0x00	; 0
     214:	84 2f       	mov	r24, r20
     216:	90 e0       	ldi	r25, 0x00	; 0
  }
  if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail;
     218:	82 1b       	sub	r24, r18
     21a:	93 0b       	sbc	r25, r19
     21c:	54 17       	cp	r21, r20
     21e:	10 f0       	brcs	.+4      	; 0x224 <_ZN14HardwareSerial17availableForWriteEv+0x1a>
     220:	cf 96       	adiw	r24, 0x3f	; 63
     222:	08 95       	ret
  return tail - head - 1;
     224:	01 97       	sbiw	r24, 0x01	; 1
}
     226:	08 95       	ret

00000228 <_ZN14HardwareSerial4readEv>:
    return _rx_buffer[_rx_buffer_tail];
  }
}

int HardwareSerial::read(void)
{
     228:	fc 01       	movw	r30, r24
  // if the head isn't ahead of the tail, we don't have any characters
  if (_rx_buffer_head == _rx_buffer_tail) {
     22a:	91 8d       	ldd	r25, Z+25	; 0x19
     22c:	82 8d       	ldd	r24, Z+26	; 0x1a
     22e:	98 17       	cp	r25, r24
     230:	61 f0       	breq	.+24     	; 0x24a <_ZN14HardwareSerial4readEv+0x22>
    return -1;
  } else {
    unsigned char c = _rx_buffer[_rx_buffer_tail];
     232:	a2 8d       	ldd	r26, Z+26	; 0x1a
     234:	ae 0f       	add	r26, r30
     236:	bf 2f       	mov	r27, r31
     238:	b1 1d       	adc	r27, r1
     23a:	5d 96       	adiw	r26, 0x1d	; 29
     23c:	8c 91       	ld	r24, X
    _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
     23e:	92 8d       	ldd	r25, Z+26	; 0x1a
     240:	9f 5f       	subi	r25, 0xFF	; 255
     242:	9f 73       	andi	r25, 0x3F	; 63
     244:	92 8f       	std	Z+26, r25	; 0x1a
    return c;
     246:	90 e0       	ldi	r25, 0x00	; 0
     248:	08 95       	ret

int HardwareSerial::read(void)
{
  // if the head isn't ahead of the tail, we don't have any characters
  if (_rx_buffer_head == _rx_buffer_tail) {
    return -1;
     24a:	8f ef       	ldi	r24, 0xFF	; 255
     24c:	9f ef       	ldi	r25, 0xFF	; 255
  } else {
    unsigned char c = _rx_buffer[_rx_buffer_tail];
    _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
    return c;
  }
}
     24e:	08 95       	ret

00000250 <_ZN14HardwareSerial4peekEv>:
{
  return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE;
}

int HardwareSerial::peek(void)
{
     250:	fc 01       	movw	r30, r24
  if (_rx_buffer_head == _rx_buffer_tail) {
     252:	91 8d       	ldd	r25, Z+25	; 0x19
     254:	82 8d       	ldd	r24, Z+26	; 0x1a
     256:	98 17       	cp	r25, r24
     258:	31 f0       	breq	.+12     	; 0x266 <_ZN14HardwareSerial4peekEv+0x16>
    return -1;
  } else {
    return _rx_buffer[_rx_buffer_tail];
     25a:	82 8d       	ldd	r24, Z+26	; 0x1a
     25c:	e8 0f       	add	r30, r24
     25e:	f1 1d       	adc	r31, r1
     260:	85 8d       	ldd	r24, Z+29	; 0x1d
     262:	90 e0       	ldi	r25, 0x00	; 0
     264:	08 95       	ret
}

int HardwareSerial::peek(void)
{
  if (_rx_buffer_head == _rx_buffer_tail) {
    return -1;
     266:	8f ef       	ldi	r24, 0xFF	; 255
     268:	9f ef       	ldi	r25, 0xFF	; 255
  } else {
    return _rx_buffer[_rx_buffer_tail];
  }
}
     26a:	08 95       	ret

0000026c <_ZN14HardwareSerial9availableEv>:
  // clear any received data
  _rx_buffer_head = _rx_buffer_tail;
}

int HardwareSerial::available(void)
{
     26c:	fc 01       	movw	r30, r24
  return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE;
     26e:	91 8d       	ldd	r25, Z+25	; 0x19
     270:	22 8d       	ldd	r18, Z+26	; 0x1a
     272:	89 2f       	mov	r24, r25
     274:	90 e0       	ldi	r25, 0x00	; 0
     276:	80 5c       	subi	r24, 0xC0	; 192
     278:	9f 4f       	sbci	r25, 0xFF	; 255
     27a:	82 1b       	sub	r24, r18
     27c:	91 09       	sbc	r25, r1
}
     27e:	8f 73       	andi	r24, 0x3F	; 63
     280:	99 27       	eor	r25, r25
     282:	08 95       	ret

00000284 <_Z17Serial0_availablev>:
#endif

// Function that can be weakly referenced by serialEventRun to prevent
// pulling in this file if it's not otherwise used.
bool Serial0_available() {
  return Serial.available();
     284:	86 e8       	ldi	r24, 0x86	; 134
     286:	92 e0       	ldi	r25, 0x02	; 2
     288:	0e 94 36 01 	call	0x26c	; 0x26c <_ZN14HardwareSerial9availableEv>
     28c:	21 e0       	ldi	r18, 0x01	; 1
     28e:	89 2b       	or	r24, r25
     290:	09 f4       	brne	.+2      	; 0x294 <_Z17Serial0_availablev+0x10>
     292:	20 e0       	ldi	r18, 0x00	; 0
}
     294:	82 2f       	mov	r24, r18
     296:	08 95       	ret

00000298 <_Z14serialEventRunv>:
#endif

void serialEventRun(void)
{
#if defined(HAVE_HWSERIAL0)
  if (Serial0_available && serialEvent && Serial0_available()) serialEvent();
     298:	80 e0       	ldi	r24, 0x00	; 0
     29a:	90 e0       	ldi	r25, 0x00	; 0
     29c:	89 2b       	or	r24, r25
     29e:	29 f0       	breq	.+10     	; 0x2aa <_Z14serialEventRunv+0x12>
     2a0:	0e 94 42 01 	call	0x284	; 0x284 <_Z17Serial0_availablev>
     2a4:	81 11       	cpse	r24, r1
     2a6:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>
  if (Serial2_available && serialEvent2 && Serial2_available()) serialEvent2();
#endif
#if defined(HAVE_HWSERIAL3)
  if (Serial3_available && serialEvent3 && Serial3_available()) serialEvent3();
#endif
}
     2aa:	08 95       	ret

000002ac <_ZN14HardwareSerial17_tx_udr_empty_irqEv>:
#endif

// Actual interrupt handlers //////////////////////////////////////////////////////////////

void HardwareSerial::_tx_udr_empty_irq(void)
{
     2ac:	fc 01       	movw	r30, r24
  // If interrupts are enabled, there must be more data in the output
  // buffer. Send the next byte
  unsigned char c = _tx_buffer[_tx_buffer_tail];
     2ae:	a4 8d       	ldd	r26, Z+28	; 0x1c
     2b0:	a8 0f       	add	r26, r24
     2b2:	b9 2f       	mov	r27, r25
     2b4:	b1 1d       	adc	r27, r1
     2b6:	a3 5a       	subi	r26, 0xA3	; 163
     2b8:	bf 4f       	sbci	r27, 0xFF	; 255
     2ba:	2c 91       	ld	r18, X
  _tx_buffer_tail = (_tx_buffer_tail + 1) % SERIAL_TX_BUFFER_SIZE;
     2bc:	84 8d       	ldd	r24, Z+28	; 0x1c
     2be:	90 e0       	ldi	r25, 0x00	; 0
     2c0:	01 96       	adiw	r24, 0x01	; 1
     2c2:	8f 73       	andi	r24, 0x3F	; 63
     2c4:	99 27       	eor	r25, r25
     2c6:	84 8f       	std	Z+28, r24	; 0x1c

  *_udr = c;
     2c8:	a6 89       	ldd	r26, Z+22	; 0x16
     2ca:	b7 89       	ldd	r27, Z+23	; 0x17
     2cc:	2c 93       	st	X, r18
  // location". This makes sure flush() won't return until the bytes
  // actually got written. Other r/w bits are preserved, and zeroes
  // written to the rest.

#ifdef MPCM0
  *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0);
     2ce:	a0 89       	ldd	r26, Z+16	; 0x10
     2d0:	b1 89       	ldd	r27, Z+17	; 0x11
     2d2:	8c 91       	ld	r24, X
     2d4:	83 70       	andi	r24, 0x03	; 3
     2d6:	80 64       	ori	r24, 0x40	; 64
     2d8:	8c 93       	st	X, r24
#else
  *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0)));
#endif

  if (_tx_buffer_head == _tx_buffer_tail) {
     2da:	93 8d       	ldd	r25, Z+27	; 0x1b
     2dc:	84 8d       	ldd	r24, Z+28	; 0x1c
     2de:	98 13       	cpse	r25, r24
     2e0:	06 c0       	rjmp	.+12     	; 0x2ee <_ZN14HardwareSerial17_tx_udr_empty_irqEv+0x42>
    // Buffer empty, so disable interrupts
    cbi(*_ucsrb, UDRIE0);
     2e2:	02 88       	ldd	r0, Z+18	; 0x12
     2e4:	f3 89       	ldd	r31, Z+19	; 0x13
     2e6:	e0 2d       	mov	r30, r0
     2e8:	80 81       	ld	r24, Z
     2ea:	8f 7d       	andi	r24, 0xDF	; 223
     2ec:	80 83       	st	Z, r24
  }
}
     2ee:	08 95       	ret

000002f0 <_ZN14HardwareSerial5writeEh>:
  // If we get here, nothing is queued anymore (DRIE is disabled) and
  // the hardware finished tranmission (TXC is set).
}

size_t HardwareSerial::write(uint8_t c)
{
     2f0:	ef 92       	push	r14
     2f2:	ff 92       	push	r15
     2f4:	0f 93       	push	r16
     2f6:	1f 93       	push	r17
     2f8:	cf 93       	push	r28
     2fa:	df 93       	push	r29
     2fc:	ec 01       	movw	r28, r24
  _written = true;
     2fe:	81 e0       	ldi	r24, 0x01	; 1
     300:	88 8f       	std	Y+24, r24	; 0x18
  // If the buffer and the data register is empty, just write the byte
  // to the data register and be done. This shortcut helps
  // significantly improve the effective datarate at high (>
  // 500kbit/s) bitrates, where interrupt overhead becomes a slowdown.
  if (_tx_buffer_head == _tx_buffer_tail && bit_is_set(*_ucsra, UDRE0)) {
     302:	9b 8d       	ldd	r25, Y+27	; 0x1b
     304:	8c 8d       	ldd	r24, Y+28	; 0x1c
     306:	98 13       	cpse	r25, r24
     308:	1a c0       	rjmp	.+52     	; 0x33e <_ZN14HardwareSerial5writeEh+0x4e>
     30a:	e8 89       	ldd	r30, Y+16	; 0x10
     30c:	f9 89       	ldd	r31, Y+17	; 0x11
     30e:	80 81       	ld	r24, Z
     310:	85 ff       	sbrs	r24, 5
     312:	15 c0       	rjmp	.+42     	; 0x33e <_ZN14HardwareSerial5writeEh+0x4e>
    // So writing UDR must happen first.
    // Writing UDR and clearing TC must be done atomically, otherwise
    // interrupts might delay the TXC clear so the byte written to UDR
    // is transmitted (setting TXC) before clearing TXC. Then TXC will
    // be cleared when no bytes are left, causing flush() to hang
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
     314:	9f b7       	in	r25, 0x3f	; 63
    return 1;
}

static __inline__ uint8_t __iCliRetVal(void)
{
    cli();
     316:	f8 94       	cli
      *_udr = c;
     318:	ee 89       	ldd	r30, Y+22	; 0x16
     31a:	ff 89       	ldd	r31, Y+23	; 0x17
     31c:	60 83       	st	Z, r22
#ifdef MPCM0
      *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0);
     31e:	e8 89       	ldd	r30, Y+16	; 0x10
     320:	f9 89       	ldd	r31, Y+17	; 0x11
     322:	80 81       	ld	r24, Z
     324:	83 70       	andi	r24, 0x03	; 3
     326:	80 64       	ori	r24, 0x40	; 64
  // make atomic to prevent execution of ISR between setting the
  // head pointer and setting the interrupt flag resulting in buffer
  // retransmission
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    _tx_buffer_head = i;
    sbi(*_ucsrb, UDRIE0);
     328:	80 83       	st	Z, r24
    (void)__s;
}

static __inline__ void __iRestore(const  uint8_t *__s)
{
    SREG = *__s;
     32a:	9f bf       	out	0x3f, r25	; 63
  }
  
  return 1;
}
     32c:	81 e0       	ldi	r24, 0x01	; 1
     32e:	90 e0       	ldi	r25, 0x00	; 0
     330:	df 91       	pop	r29
     332:	cf 91       	pop	r28
     334:	1f 91       	pop	r17
     336:	0f 91       	pop	r16
     338:	ff 90       	pop	r15
     33a:	ef 90       	pop	r14
     33c:	08 95       	ret
     33e:	f6 2e       	mov	r15, r22
      *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0)));
#endif
    }
    return 1;
  }
  tx_buffer_index_t i = (_tx_buffer_head + 1) % SERIAL_TX_BUFFER_SIZE;
     340:	0b 8d       	ldd	r16, Y+27	; 0x1b
     342:	10 e0       	ldi	r17, 0x00	; 0
     344:	0f 5f       	subi	r16, 0xFF	; 255
     346:	1f 4f       	sbci	r17, 0xFF	; 255
     348:	0f 73       	andi	r16, 0x3F	; 63
     34a:	11 27       	eor	r17, r17
     34c:	e0 2e       	mov	r14, r16
	
  // If the output buffer is full, there's nothing for it other than to 
  // wait for the interrupt handler to empty it a bit
  while (i == _tx_buffer_tail) {
     34e:	8c 8d       	ldd	r24, Y+28	; 0x1c
     350:	8e 11       	cpse	r24, r14
     352:	0c c0       	rjmp	.+24     	; 0x36c <_ZN14HardwareSerial5writeEh+0x7c>
    if (bit_is_clear(SREG, SREG_I)) {
     354:	0f b6       	in	r0, 0x3f	; 63
     356:	07 fc       	sbrc	r0, 7
     358:	fa cf       	rjmp	.-12     	; 0x34e <_ZN14HardwareSerial5writeEh+0x5e>
      // Interrupts are disabled, so we'll have to poll the data
      // register empty flag ourselves. If it is set, pretend an
      // interrupt has happened and call the handler to free up
      // space for us.
      if(bit_is_set(*_ucsra, UDRE0))
     35a:	e8 89       	ldd	r30, Y+16	; 0x10
     35c:	f9 89       	ldd	r31, Y+17	; 0x11
     35e:	80 81       	ld	r24, Z
     360:	85 ff       	sbrs	r24, 5
     362:	f5 cf       	rjmp	.-22     	; 0x34e <_ZN14HardwareSerial5writeEh+0x5e>
	_tx_udr_empty_irq();
     364:	ce 01       	movw	r24, r28
     366:	0e 94 56 01 	call	0x2ac	; 0x2ac <_ZN14HardwareSerial17_tx_udr_empty_irqEv>
     36a:	f1 cf       	rjmp	.-30     	; 0x34e <_ZN14HardwareSerial5writeEh+0x5e>
    } else {
      // nop, the interrupt handler will free up space for us
    }
  }

  _tx_buffer[_tx_buffer_head] = c;
     36c:	eb 8d       	ldd	r30, Y+27	; 0x1b
     36e:	ec 0f       	add	r30, r28
     370:	fd 2f       	mov	r31, r29
     372:	f1 1d       	adc	r31, r1
     374:	e3 5a       	subi	r30, 0xA3	; 163
     376:	ff 4f       	sbci	r31, 0xFF	; 255
     378:	f0 82       	st	Z, r15

  // make atomic to prevent execution of ISR between setting the
  // head pointer and setting the interrupt flag resulting in buffer
  // retransmission
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
     37a:	9f b7       	in	r25, 0x3f	; 63
    return 1;
}

static __inline__ uint8_t __iCliRetVal(void)
{
    cli();
     37c:	f8 94       	cli
    _tx_buffer_head = i;
     37e:	0b 8f       	std	Y+27, r16	; 0x1b
    sbi(*_ucsrb, UDRIE0);
     380:	ea 89       	ldd	r30, Y+18	; 0x12
     382:	fb 89       	ldd	r31, Y+19	; 0x13
     384:	80 81       	ld	r24, Z
     386:	80 62       	ori	r24, 0x20	; 32
     388:	cf cf       	rjmp	.-98     	; 0x328 <_ZN14HardwareSerial5writeEh+0x38>

0000038a <_ZN14HardwareSerial5flushEv>:
  if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail;
  return tail - head - 1;
}

void HardwareSerial::flush()
{
     38a:	cf 93       	push	r28
     38c:	df 93       	push	r29
     38e:	ec 01       	movw	r28, r24
  // If we have never written a byte, no need to flush. This special
  // case is needed since there is no way to force the TXC (transmit
  // complete) bit to 1 during initialization
  if (!_written)
     390:	88 8d       	ldd	r24, Y+24	; 0x18
     392:	88 23       	and	r24, r24
     394:	b9 f0       	breq	.+46     	; 0x3c4 <_ZN14HardwareSerial5flushEv+0x3a>
    return;

  while (bit_is_set(*_ucsrb, UDRIE0) || bit_is_clear(*_ucsra, TXC0)) {
     396:	aa 89       	ldd	r26, Y+18	; 0x12
     398:	bb 89       	ldd	r27, Y+19	; 0x13
     39a:	e8 89       	ldd	r30, Y+16	; 0x10
     39c:	f9 89       	ldd	r31, Y+17	; 0x11
     39e:	8c 91       	ld	r24, X
     3a0:	85 fd       	sbrc	r24, 5
     3a2:	03 c0       	rjmp	.+6      	; 0x3aa <_ZN14HardwareSerial5flushEv+0x20>
     3a4:	80 81       	ld	r24, Z
     3a6:	86 fd       	sbrc	r24, 6
     3a8:	0d c0       	rjmp	.+26     	; 0x3c4 <_ZN14HardwareSerial5flushEv+0x3a>
    if (bit_is_clear(SREG, SREG_I) && bit_is_set(*_ucsrb, UDRIE0))
     3aa:	0f b6       	in	r0, 0x3f	; 63
     3ac:	07 fc       	sbrc	r0, 7
     3ae:	f7 cf       	rjmp	.-18     	; 0x39e <_ZN14HardwareSerial5flushEv+0x14>
     3b0:	8c 91       	ld	r24, X
     3b2:	85 ff       	sbrs	r24, 5
     3b4:	f2 cf       	rjmp	.-28     	; 0x39a <_ZN14HardwareSerial5flushEv+0x10>
	// Interrupts are globally disabled, but the DR empty
	// interrupt should be enabled, so poll the DR empty flag to
	// prevent deadlock
	if (bit_is_set(*_ucsra, UDRE0))
     3b6:	80 81       	ld	r24, Z
     3b8:	85 ff       	sbrs	r24, 5
     3ba:	ed cf       	rjmp	.-38     	; 0x396 <_ZN14HardwareSerial5flushEv+0xc>
	  _tx_udr_empty_irq();
     3bc:	ce 01       	movw	r24, r28
     3be:	0e 94 56 01 	call	0x2ac	; 0x2ac <_ZN14HardwareSerial17_tx_udr_empty_irqEv>
     3c2:	e9 cf       	rjmp	.-46     	; 0x396 <_ZN14HardwareSerial5flushEv+0xc>
  }
  // If we get here, nothing is queued anymore (DRIE is disabled) and
  // the hardware finished tranmission (TXC is set).
}
     3c4:	df 91       	pop	r29
     3c6:	cf 91       	pop	r28
     3c8:	08 95       	ret

000003ca <turnOffPWM>:
//
//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
//static inline void turnOffPWM(uint8_t timer)
static void turnOffPWM(uint8_t timer)
{
	switch (timer)
     3ca:	83 30       	cpi	r24, 0x03	; 3
     3cc:	81 f0       	breq	.+32     	; 0x3ee <turnOffPWM+0x24>
     3ce:	28 f4       	brcc	.+10     	; 0x3da <turnOffPWM+0x10>
     3d0:	81 30       	cpi	r24, 0x01	; 1
     3d2:	99 f0       	breq	.+38     	; 0x3fa <turnOffPWM+0x30>
     3d4:	82 30       	cpi	r24, 0x02	; 2
     3d6:	a9 f0       	breq	.+42     	; 0x402 <__LOCK_REGION_LENGTH__+0x2>
     3d8:	08 95       	ret
     3da:	87 30       	cpi	r24, 0x07	; 7
     3dc:	a9 f0       	breq	.+42     	; 0x408 <__LOCK_REGION_LENGTH__+0x8>
     3de:	88 30       	cpi	r24, 0x08	; 8
     3e0:	c9 f0       	breq	.+50     	; 0x414 <__LOCK_REGION_LENGTH__+0x14>
     3e2:	84 30       	cpi	r24, 0x04	; 4
     3e4:	b1 f4       	brne	.+44     	; 0x412 <__LOCK_REGION_LENGTH__+0x12>
	{
		#if defined(TCCR1A) && defined(COM1A1)
		case TIMER1A:   cbi(TCCR1A, COM1A1);    break;
		#endif
		#if defined(TCCR1A) && defined(COM1B1)
		case TIMER1B:   cbi(TCCR1A, COM1B1);    break;
     3e6:	80 91 80 00 	lds	r24, 0x0080	; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
     3ea:	8f 7d       	andi	r24, 0xDF	; 223
     3ec:	03 c0       	rjmp	.+6      	; 0x3f4 <turnOffPWM+0x2a>
static void turnOffPWM(uint8_t timer)
{
	switch (timer)
	{
		#if defined(TCCR1A) && defined(COM1A1)
		case TIMER1A:   cbi(TCCR1A, COM1A1);    break;
     3ee:	80 91 80 00 	lds	r24, 0x0080	; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
     3f2:	8f 77       	andi	r24, 0x7F	; 127
		#endif
		#if defined(TCCR1A) && defined(COM1B1)
		case TIMER1B:   cbi(TCCR1A, COM1B1);    break;
     3f4:	80 93 80 00 	sts	0x0080, r24	; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
     3f8:	08 95       	ret
		#if defined(TCCR2) && defined(COM21)
		case  TIMER2:   cbi(TCCR2, COM21);      break;
		#endif
		
		#if defined(TCCR0A) && defined(COM0A1)
		case  TIMER0A:  cbi(TCCR0A, COM0A1);    break;
     3fa:	84 b5       	in	r24, 0x24	; 36
     3fc:	8f 77       	andi	r24, 0x7F	; 127
		#endif
		
		#if defined(TCCR0A) && defined(COM0B1)
		case  TIMER0B:  cbi(TCCR0A, COM0B1);    break;
     3fe:	84 bd       	out	0x24, r24	; 36
     400:	08 95       	ret
     402:	84 b5       	in	r24, 0x24	; 36
     404:	8f 7d       	andi	r24, 0xDF	; 223
     406:	fb cf       	rjmp	.-10     	; 0x3fe <turnOffPWM+0x34>
		#endif
		#if defined(TCCR2A) && defined(COM2A1)
		case  TIMER2A:  cbi(TCCR2A, COM2A1);    break;
     408:	80 91 b0 00 	lds	r24, 0x00B0	; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
     40c:	8f 77       	andi	r24, 0x7F	; 127
		#endif
		#if defined(TCCR2A) && defined(COM2B1)
		case  TIMER2B:  cbi(TCCR2A, COM2B1);    break;
     40e:	80 93 b0 00 	sts	0x00B0, r24	; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
		case  TIMER5A:  cbi(TCCR5A, COM5A1);    break;
		case  TIMER5B:  cbi(TCCR5A, COM5B1);    break;
		case  TIMER5C:  cbi(TCCR5A, COM5C1);    break;
		#endif
	}
}
     412:	08 95       	ret
		#endif
		#if defined(TCCR2A) && defined(COM2A1)
		case  TIMER2A:  cbi(TCCR2A, COM2A1);    break;
		#endif
		#if defined(TCCR2A) && defined(COM2B1)
		case  TIMER2B:  cbi(TCCR2A, COM2B1);    break;
     414:	80 91 b0 00 	lds	r24, 0x00B0	; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
     418:	8f 7d       	andi	r24, 0xDF	; 223
     41a:	f9 cf       	rjmp	.-14     	; 0x40e <__LOCK_REGION_LENGTH__+0xe>

0000041c <digitalWrite>:
		#endif
	}
}

void digitalWrite(uint8_t pin, uint8_t val)
{
     41c:	1f 93       	push	r17
     41e:	cf 93       	push	r28
     420:	df 93       	push	r29
	uint8_t timer = digitalPinToTimer(pin);
     422:	28 2f       	mov	r18, r24
     424:	30 e0       	ldi	r19, 0x00	; 0
     426:	f9 01       	movw	r30, r18
     428:	e4 5c       	subi	r30, 0xC4	; 196
     42a:	fe 4f       	sbci	r31, 0xFE	; 254
     42c:	84 91       	lpm	r24, Z
	uint8_t bit = digitalPinToBitMask(pin);
     42e:	f9 01       	movw	r30, r18
     430:	e8 5d       	subi	r30, 0xD8	; 216
     432:	fe 4f       	sbci	r31, 0xFE	; 254
     434:	d4 91       	lpm	r29, Z
	uint8_t port = digitalPinToPort(pin);
     436:	f9 01       	movw	r30, r18
     438:	ec 5e       	subi	r30, 0xEC	; 236
     43a:	fe 4f       	sbci	r31, 0xFE	; 254
     43c:	c4 91       	lpm	r28, Z
	volatile uint8_t *out;

	if (port == NOT_A_PIN) return;
     43e:	cc 23       	and	r28, r28
     440:	a9 f0       	breq	.+42     	; 0x46c <digitalWrite+0x50>
     442:	16 2f       	mov	r17, r22

	// If the pin that support PWM output, we need to turn it off
	// before doing a digital write.
	if (timer != NOT_ON_TIMER) turnOffPWM(timer);
     444:	81 11       	cpse	r24, r1
     446:	0e 94 e5 01 	call	0x3ca	; 0x3ca <turnOffPWM>

	out = portOutputRegister(port);
     44a:	ec 2f       	mov	r30, r28
     44c:	f0 e0       	ldi	r31, 0x00	; 0
     44e:	ee 0f       	add	r30, r30
     450:	ff 1f       	adc	r31, r31
     452:	e6 51       	subi	r30, 0x16	; 22
     454:	ff 4f       	sbci	r31, 0xFF	; 255
     456:	a5 91       	lpm	r26, Z+
     458:	b4 91       	lpm	r27, Z

	uint8_t oldSREG = SREG;
     45a:	8f b7       	in	r24, 0x3f	; 63
	cli();
     45c:	f8 94       	cli

	if (val == LOW) {
		*out &= ~bit;
     45e:	ec 91       	ld	r30, X
	out = portOutputRegister(port);

	uint8_t oldSREG = SREG;
	cli();

	if (val == LOW) {
     460:	11 11       	cpse	r17, r1
     462:	08 c0       	rjmp	.+16     	; 0x474 <digitalWrite+0x58>
		*out &= ~bit;
     464:	d0 95       	com	r29
     466:	de 23       	and	r29, r30
	} else {
		*out |= bit;
     468:	dc 93       	st	X, r29
	}

	SREG = oldSREG;
     46a:	8f bf       	out	0x3f, r24	; 63
}
     46c:	df 91       	pop	r29
     46e:	cf 91       	pop	r28
     470:	1f 91       	pop	r17
     472:	08 95       	ret
	cli();

	if (val == LOW) {
		*out &= ~bit;
	} else {
		*out |= bit;
     474:	de 2b       	or	r29, r30
     476:	f8 cf       	rjmp	.-16     	; 0x468 <digitalWrite+0x4c>

00000478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>:
    @brief  Encapsulate hardware and software SPI transfer into one function
    @param x the data byte to transfer
    @returns the data byte read from the device
*/
/**************************************************************************/
uint8_t Adafruit_BME280::spixfer(uint8_t x) {
     478:	cf 92       	push	r12
     47a:	df 92       	push	r13
     47c:	ef 92       	push	r14
     47e:	ff 92       	push	r15
     480:	0f 93       	push	r16
     482:	1f 93       	push	r17
     484:	cf 93       	push	r28
     486:	df 93       	push	r29
    // hardware SPI
    if (_sck == -1)
     488:	90 91 3d 03 	lds	r25, 0x033D	; 0x80033d <bme+0xe>
     48c:	9f 3f       	cpi	r25, 0xFF	; 255
     48e:	81 f4       	brne	.+32     	; 0x4b0 <_ZN15Adafruit_BME2807spixferEh.constprop.47+0x38>

  // Write to the SPI bus (MOSI pin) and also receive (MISO pin)
  inline static uint8_t transfer(uint8_t data) {
    SPDR = data;
     490:	8e bd       	out	0x2e, r24	; 46
     * The following NOP introduces a small delay that can prevent the wait
     * loop form iterating when running at the maximum speed. This gives
     * about 10% more speed, even if it seems counter-intuitive. At lower
     * speeds it is unnoticed.
     */
    asm volatile("nop");
     492:	00 00       	nop
    while (!(SPSR & _BV(SPIF))) ; // wait
     494:	0d b4       	in	r0, 0x2d	; 45
     496:	07 fe       	sbrs	r0, 7
     498:	fd cf       	rjmp	.-6      	; 0x494 <_ZN15Adafruit_BME2807spixferEh.constprop.47+0x1c>
    return SPDR;
     49a:	fe b4       	in	r15, 0x2e	; 46
        digitalWrite(_sck, HIGH);
        if (digitalRead(_miso))
            reply |= 1;
        }
    return reply;
}
     49c:	8f 2d       	mov	r24, r15
     49e:	df 91       	pop	r29
     4a0:	cf 91       	pop	r28
     4a2:	1f 91       	pop	r17
     4a4:	0f 91       	pop	r16
     4a6:	ff 90       	pop	r15
     4a8:	ef 90       	pop	r14
     4aa:	df 90       	pop	r13
     4ac:	cf 90       	pop	r12
     4ae:	08 95       	ret
     4b0:	d8 2e       	mov	r13, r24
    // hardware SPI
    if (_sck == -1)
        return SPI.transfer(x);

    // software SPI
    uint8_t reply = 0;
     4b2:	f1 2c       	mov	r15, r1
    for (int i=7; i>=0; i--) {
     4b4:	c7 e0       	ldi	r28, 0x07	; 7
     4b6:	d0 e0       	ldi	r29, 0x00	; 0
        reply <<= 1;
        digitalWrite(_sck, LOW);
        digitalWrite(_mosi, x & (1<<i));
     4b8:	01 e0       	ldi	r16, 0x01	; 1
     4ba:	10 e0       	ldi	r17, 0x00	; 0
        return SPI.transfer(x);

    // software SPI
    uint8_t reply = 0;
    for (int i=7; i>=0; i--) {
        reply <<= 1;
     4bc:	ff 0c       	add	r15, r15
        digitalWrite(_sck, LOW);
     4be:	60 e0       	ldi	r22, 0x00	; 0
     4c0:	80 91 3d 03 	lds	r24, 0x033D	; 0x80033d <bme+0xe>
     4c4:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
        digitalWrite(_mosi, x & (1<<i));
     4c8:	b8 01       	movw	r22, r16
     4ca:	0c 2e       	mov	r0, r28
     4cc:	01 c0       	rjmp	.+2      	; 0x4d0 <_ZN15Adafruit_BME2807spixferEh.constprop.47+0x58>
     4ce:	66 0f       	add	r22, r22
     4d0:	0a 94       	dec	r0
     4d2:	ea f7       	brpl	.-6      	; 0x4ce <_ZN15Adafruit_BME2807spixferEh.constprop.47+0x56>
     4d4:	6d 21       	and	r22, r13
     4d6:	80 91 3b 03 	lds	r24, 0x033B	; 0x80033b <bme+0xc>
     4da:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
        digitalWrite(_sck, HIGH);
     4de:	61 e0       	ldi	r22, 0x01	; 1
     4e0:	80 91 3d 03 	lds	r24, 0x033D	; 0x80033d <bme+0xe>
     4e4:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
	SREG = oldSREG;
}

int digitalRead(uint8_t pin)
{
	uint8_t timer = digitalPinToTimer(pin);
     4e8:	20 91 3c 03 	lds	r18, 0x033C	; 0x80033c <bme+0xd>
     4ec:	30 e0       	ldi	r19, 0x00	; 0
     4ee:	f9 01       	movw	r30, r18
     4f0:	e4 5c       	subi	r30, 0xC4	; 196
     4f2:	fe 4f       	sbci	r31, 0xFE	; 254
     4f4:	84 91       	lpm	r24, Z
	uint8_t bit = digitalPinToBitMask(pin);
     4f6:	f9 01       	movw	r30, r18
     4f8:	e8 5d       	subi	r30, 0xD8	; 216
     4fa:	fe 4f       	sbci	r31, 0xFE	; 254
     4fc:	e4 90       	lpm	r14, Z
	uint8_t port = digitalPinToPort(pin);
     4fe:	f9 01       	movw	r30, r18
     500:	ec 5e       	subi	r30, 0xEC	; 236
     502:	fe 4f       	sbci	r31, 0xFE	; 254
     504:	c4 90       	lpm	r12, Z

	if (port == NOT_A_PIN) return LOW;
     506:	cc 20       	and	r12, r12
     508:	81 f0       	breq	.+32     	; 0x52a <_ZN15Adafruit_BME2807spixferEh.constprop.47+0xb2>

	// If the pin that support PWM output, we need to turn it off
	// before getting a digital reading.
	if (timer != NOT_ON_TIMER) turnOffPWM(timer);
     50a:	81 11       	cpse	r24, r1
     50c:	0e 94 e5 01 	call	0x3ca	; 0x3ca <turnOffPWM>

	if (*portInputRegister(port) & bit) return HIGH;
     510:	ec 2d       	mov	r30, r12
     512:	f0 e0       	ldi	r31, 0x00	; 0
     514:	ee 0f       	add	r30, r30
     516:	ff 1f       	adc	r31, r31
     518:	e6 5f       	subi	r30, 0xF6	; 246
     51a:	fe 4f       	sbci	r31, 0xFE	; 254
     51c:	a5 91       	lpm	r26, Z+
     51e:	b4 91       	lpm	r27, Z
     520:	ec 91       	ld	r30, X
     522:	ee 22       	and	r14, r30
     524:	11 f0       	breq	.+4      	; 0x52a <_ZN15Adafruit_BME2807spixferEh.constprop.47+0xb2>
        if (digitalRead(_miso))
            reply |= 1;
     526:	68 94       	set
     528:	f0 f8       	bld	r15, 0
    if (_sck == -1)
        return SPI.transfer(x);

    // software SPI
    uint8_t reply = 0;
    for (int i=7; i>=0; i--) {
     52a:	21 97       	sbiw	r28, 0x01	; 1
     52c:	08 f0       	brcs	.+2      	; 0x530 <_ZN15Adafruit_BME2807spixferEh.constprop.47+0xb8>
     52e:	c6 cf       	rjmp	.-116    	; 0x4bc <_ZN15Adafruit_BME2807spixferEh.constprop.47+0x44>
     530:	b5 cf       	rjmp	.-150    	; 0x49c <_ZN15Adafruit_BME2807spixferEh.constprop.47+0x24>

00000532 <pinMode>:
#define ARDUINO_MAIN
#include "wiring_private.h"
#include "pins_arduino.h"

void pinMode(uint8_t pin, uint8_t mode)
{
     532:	cf 93       	push	r28
     534:	df 93       	push	r29
	uint8_t bit = digitalPinToBitMask(pin);
     536:	90 e0       	ldi	r25, 0x00	; 0
     538:	fc 01       	movw	r30, r24
     53a:	e8 5d       	subi	r30, 0xD8	; 216
     53c:	fe 4f       	sbci	r31, 0xFE	; 254
     53e:	24 91       	lpm	r18, Z
	uint8_t port = digitalPinToPort(pin);
     540:	8c 5e       	subi	r24, 0xEC	; 236
     542:	9e 4f       	sbci	r25, 0xFE	; 254
     544:	fc 01       	movw	r30, r24
     546:	84 91       	lpm	r24, Z
	volatile uint8_t *reg, *out;

	if (port == NOT_A_PIN) return;
     548:	88 23       	and	r24, r24
     54a:	d1 f0       	breq	.+52     	; 0x580 <pinMode+0x4e>

	// JWS: can I let the optimizer do this?
	reg = portModeRegister(port);
     54c:	90 e0       	ldi	r25, 0x00	; 0
     54e:	88 0f       	add	r24, r24
     550:	99 1f       	adc	r25, r25
     552:	fc 01       	movw	r30, r24
     554:	ec 50       	subi	r30, 0x0C	; 12
     556:	ff 4f       	sbci	r31, 0xFF	; 255
     558:	a5 91       	lpm	r26, Z+
     55a:	b4 91       	lpm	r27, Z
	out = portOutputRegister(port);
     55c:	fc 01       	movw	r30, r24
     55e:	e6 51       	subi	r30, 0x16	; 22
     560:	ff 4f       	sbci	r31, 0xFF	; 255
     562:	c5 91       	lpm	r28, Z+
     564:	d4 91       	lpm	r29, Z

	if (mode == INPUT) { 
     566:	61 11       	cpse	r22, r1
     568:	0e c0       	rjmp	.+28     	; 0x586 <pinMode+0x54>
		uint8_t oldSREG = SREG;
     56a:	9f b7       	in	r25, 0x3f	; 63
                cli();
     56c:	f8 94       	cli
		*reg &= ~bit;
     56e:	8c 91       	ld	r24, X
     570:	e2 2f       	mov	r30, r18
     572:	e0 95       	com	r30
     574:	8e 23       	and	r24, r30
     576:	8c 93       	st	X, r24
		*out &= ~bit;
     578:	28 81       	ld	r18, Y
     57a:	e2 23       	and	r30, r18
     57c:	e8 83       	st	Y, r30
		SREG = oldSREG;
     57e:	9f bf       	out	0x3f, r25	; 63
		uint8_t oldSREG = SREG;
                cli();
		*reg |= bit;
		SREG = oldSREG;
	}
}
     580:	df 91       	pop	r29
     582:	cf 91       	pop	r28
     584:	08 95       	ret
                cli();
		*reg &= ~bit;
		*out |= bit;
		SREG = oldSREG;
	} else {
		uint8_t oldSREG = SREG;
     586:	8f b7       	in	r24, 0x3f	; 63
                cli();
     588:	f8 94       	cli
		*reg |= bit;
     58a:	ec 91       	ld	r30, X
     58c:	e2 2b       	or	r30, r18
     58e:	ec 93       	st	X, r30
		SREG = oldSREG;
     590:	8f bf       	out	0x3f, r24	; 63
     592:	f6 cf       	rjmp	.-20     	; 0x580 <pinMode+0x4e>

00000594 <micros>:
	return m;
}

unsigned long micros() {
	unsigned long m;
	uint8_t oldSREG = SREG, t;
     594:	3f b7       	in	r19, 0x3f	; 63
	
	cli();
     596:	f8 94       	cli
	m = timer0_overflow_count;
     598:	80 91 70 02 	lds	r24, 0x0270	; 0x800270 <timer0_overflow_count>
     59c:	90 91 71 02 	lds	r25, 0x0271	; 0x800271 <timer0_overflow_count+0x1>
     5a0:	a0 91 72 02 	lds	r26, 0x0272	; 0x800272 <timer0_overflow_count+0x2>
     5a4:	b0 91 73 02 	lds	r27, 0x0273	; 0x800273 <timer0_overflow_count+0x3>
#if defined(TCNT0)
	t = TCNT0;
     5a8:	26 b5       	in	r18, 0x26	; 38
#else
	#error TIMER 0 not defined
#endif

#ifdef TIFR0
	if ((TIFR0 & _BV(TOV0)) && (t < 255))
     5aa:	a8 9b       	sbis	0x15, 0	; 21
     5ac:	05 c0       	rjmp	.+10     	; 0x5b8 <micros+0x24>
     5ae:	2f 3f       	cpi	r18, 0xFF	; 255
     5b0:	19 f0       	breq	.+6      	; 0x5b8 <micros+0x24>
		m++;
     5b2:	01 96       	adiw	r24, 0x01	; 1
     5b4:	a1 1d       	adc	r26, r1
     5b6:	b1 1d       	adc	r27, r1
#else
	if ((TIFR & _BV(TOV0)) && (t < 255))
		m++;
#endif

	SREG = oldSREG;
     5b8:	3f bf       	out	0x3f, r19	; 63
	
	return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
     5ba:	ba 2f       	mov	r27, r26
     5bc:	a9 2f       	mov	r26, r25
     5be:	98 2f       	mov	r25, r24
     5c0:	88 27       	eor	r24, r24
     5c2:	bc 01       	movw	r22, r24
     5c4:	cd 01       	movw	r24, r26
     5c6:	62 0f       	add	r22, r18
     5c8:	71 1d       	adc	r23, r1
     5ca:	81 1d       	adc	r24, r1
     5cc:	91 1d       	adc	r25, r1
     5ce:	42 e0       	ldi	r20, 0x02	; 2
     5d0:	66 0f       	add	r22, r22
     5d2:	77 1f       	adc	r23, r23
     5d4:	88 1f       	adc	r24, r24
     5d6:	99 1f       	adc	r25, r25
     5d8:	4a 95       	dec	r20
     5da:	d1 f7       	brne	.-12     	; 0x5d0 <micros+0x3c>
}
     5dc:	08 95       	ret

000005de <delay>:

void delay(unsigned long ms)
{
     5de:	8f 92       	push	r8
     5e0:	9f 92       	push	r9
     5e2:	af 92       	push	r10
     5e4:	bf 92       	push	r11
     5e6:	cf 92       	push	r12
     5e8:	df 92       	push	r13
     5ea:	ef 92       	push	r14
     5ec:	ff 92       	push	r15
     5ee:	6b 01       	movw	r12, r22
     5f0:	7c 01       	movw	r14, r24
	uint32_t start = micros();
     5f2:	0e 94 ca 02 	call	0x594	; 0x594 <micros>
     5f6:	4b 01       	movw	r8, r22
     5f8:	5c 01       	movw	r10, r24

	while (ms > 0) {
		yield();
		while ( ms > 0 && (micros() - start) >= 1000) {
     5fa:	c1 14       	cp	r12, r1
     5fc:	d1 04       	cpc	r13, r1
     5fe:	e1 04       	cpc	r14, r1
     600:	f1 04       	cpc	r15, r1
     602:	b9 f0       	breq	.+46     	; 0x632 <delay+0x54>
     604:	0e 94 ca 02 	call	0x594	; 0x594 <micros>
     608:	68 19       	sub	r22, r8
     60a:	79 09       	sbc	r23, r9
     60c:	8a 09       	sbc	r24, r10
     60e:	9b 09       	sbc	r25, r11
     610:	68 3e       	cpi	r22, 0xE8	; 232
     612:	73 40       	sbci	r23, 0x03	; 3
     614:	81 05       	cpc	r24, r1
     616:	91 05       	cpc	r25, r1
     618:	80 f3       	brcs	.-32     	; 0x5fa <delay+0x1c>
			ms--;
     61a:	21 e0       	ldi	r18, 0x01	; 1
     61c:	c2 1a       	sub	r12, r18
     61e:	d1 08       	sbc	r13, r1
     620:	e1 08       	sbc	r14, r1
     622:	f1 08       	sbc	r15, r1
			start += 1000;
     624:	88 ee       	ldi	r24, 0xE8	; 232
     626:	88 0e       	add	r8, r24
     628:	83 e0       	ldi	r24, 0x03	; 3
     62a:	98 1e       	adc	r9, r24
     62c:	a1 1c       	adc	r10, r1
     62e:	b1 1c       	adc	r11, r1
     630:	e4 cf       	rjmp	.-56     	; 0x5fa <delay+0x1c>
		}
	}
}
     632:	ff 90       	pop	r15
     634:	ef 90       	pop	r14
     636:	df 90       	pop	r13
     638:	cf 90       	pop	r12
     63a:	bf 90       	pop	r11
     63c:	af 90       	pop	r10
     63e:	9f 90       	pop	r9
     640:	8f 90       	pop	r8
     642:	08 95       	ret

00000644 <_ZN8SPIClass14endTransactionEv>:
      #endif
      {
        SREG = interruptSave;
      }
    }
  }
     644:	08 95       	ret

00000646 <twi_stop>:
 * Output   none
 */
void twi_stop(void)
{
  // send stop condition
  TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTO);
     646:	85 ed       	ldi	r24, 0xD5	; 213
     648:	80 93 bc 00 	sts	0x00BC, r24	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>

  // wait for stop condition to be exectued on bus
  // TWINT is not set after a stop condition!
  while(TWCR & _BV(TWSTO)){
     64c:	80 91 bc 00 	lds	r24, 0x00BC	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>
     650:	84 fd       	sbrc	r24, 4
     652:	fc cf       	rjmp	.-8      	; 0x64c <twi_stop+0x6>
    continue;
  }

  // update twi state
  twi_state = TWI_READY;
     654:	10 92 7b 02 	sts	0x027B, r1	; 0x80027b <twi_state>
}
     658:	08 95       	ret

0000065a <twi_transmit>:
uint8_t twi_transmit(const uint8_t* data, uint8_t length)
{
  uint8_t i;

  // ensure data will fit into buffer
  if(TWI_BUFFER_LENGTH < (twi_txBufferLength+length)){
     65a:	20 91 24 02 	lds	r18, 0x0224	; 0x800224 <twi_txBufferLength>
     65e:	26 0f       	add	r18, r22
     660:	33 27       	eor	r19, r19
     662:	33 1f       	adc	r19, r19
     664:	21 32       	cpi	r18, 0x21	; 33
     666:	31 05       	cpc	r19, r1
     668:	ec f4       	brge	.+58     	; 0x6a4 <twi_transmit+0x4a>
    return 1;
  }
  
  // ensure we are currently a slave transmitter
  if(TWI_STX != twi_state){
     66a:	20 91 7b 02 	lds	r18, 0x027B	; 0x80027b <twi_state>
     66e:	fc 01       	movw	r30, r24
     670:	90 e0       	ldi	r25, 0x00	; 0
     672:	80 e0       	ldi	r24, 0x00	; 0
     674:	24 30       	cpi	r18, 0x04	; 4
     676:	69 f0       	breq	.+26     	; 0x692 <twi_transmit+0x38>
    return 2;
     678:	82 e0       	ldi	r24, 0x02	; 2
    twi_txBuffer[twi_txBufferLength+i] = data[i];
  }
  twi_txBufferLength += length;
  
  return 0;
}
     67a:	08 95       	ret
    return 2;
  }
  
  // set length and copy data into tx buffer
  for(i = 0; i < length; ++i){
    twi_txBuffer[twi_txBufferLength+i] = data[i];
     67c:	a0 91 24 02 	lds	r26, 0x0224	; 0x800224 <twi_txBufferLength>
     680:	21 91       	ld	r18, Z+
     682:	ac 01       	movw	r20, r24
     684:	4c 5f       	subi	r20, 0xFC	; 252
     686:	5d 4f       	sbci	r21, 0xFD	; 253
     688:	a4 0f       	add	r26, r20
     68a:	b5 2f       	mov	r27, r21
     68c:	b1 1d       	adc	r27, r1
     68e:	2c 93       	st	X, r18
     690:	01 96       	adiw	r24, 0x01	; 1
  if(TWI_STX != twi_state){
    return 2;
  }
  
  // set length and copy data into tx buffer
  for(i = 0; i < length; ++i){
     692:	86 17       	cp	r24, r22
     694:	98 f3       	brcs	.-26     	; 0x67c <twi_transmit+0x22>
    twi_txBuffer[twi_txBufferLength+i] = data[i];
  }
  twi_txBufferLength += length;
     696:	80 91 24 02 	lds	r24, 0x0224	; 0x800224 <twi_txBufferLength>
     69a:	68 0f       	add	r22, r24
     69c:	60 93 24 02 	sts	0x0224, r22	; 0x800224 <twi_txBufferLength>
     6a0:	80 e0       	ldi	r24, 0x00	; 0
     6a2:	08 95       	ret
{
  uint8_t i;

  // ensure data will fit into buffer
  if(TWI_BUFFER_LENGTH < (twi_txBufferLength+length)){
    return 1;
     6a4:	81 e0       	ldi	r24, 0x01	; 1
     6a6:	08 95       	ret

000006a8 <_ZN7TwoWire5flushEv>:
}

void TwoWire::flush(void)
{
  // XXX: to be implemented.
}
     6a8:	08 95       	ret

000006aa <_ZN7TwoWire4peekEv>:
// or after requestFrom(address, numBytes)
int TwoWire::peek(void)
{
  int value = -1;
  
  if(rxBufferIndex < rxBufferLength){
     6aa:	e0 91 7d 02 	lds	r30, 0x027D	; 0x80027d <_ZN7TwoWire13rxBufferIndexE>
     6ae:	80 91 7c 02 	lds	r24, 0x027C	; 0x80027c <_ZN7TwoWire14rxBufferLengthE>
     6b2:	e8 17       	cp	r30, r24
     6b4:	30 f4       	brcc	.+12     	; 0x6c2 <_ZN7TwoWire4peekEv+0x18>
    value = rxBuffer[rxBufferIndex];
     6b6:	f0 e0       	ldi	r31, 0x00	; 0
     6b8:	ec 51       	subi	r30, 0x1C	; 28
     6ba:	fe 4f       	sbci	r31, 0xFE	; 254
     6bc:	80 81       	ld	r24, Z
     6be:	90 e0       	ldi	r25, 0x00	; 0
     6c0:	08 95       	ret
// must be called in:
// slave rx event callback
// or after requestFrom(address, numBytes)
int TwoWire::peek(void)
{
  int value = -1;
     6c2:	8f ef       	ldi	r24, 0xFF	; 255
     6c4:	9f ef       	ldi	r25, 0xFF	; 255
  if(rxBufferIndex < rxBufferLength){
    value = rxBuffer[rxBufferIndex];
  }

  return value;
}
     6c6:	08 95       	ret

000006c8 <_ZN7TwoWire4readEv>:
int TwoWire::read(void)
{
  int value = -1;
  
  // get each successive byte on each call
  if(rxBufferIndex < rxBufferLength){
     6c8:	90 91 7d 02 	lds	r25, 0x027D	; 0x80027d <_ZN7TwoWire13rxBufferIndexE>
     6cc:	80 91 7c 02 	lds	r24, 0x027C	; 0x80027c <_ZN7TwoWire14rxBufferLengthE>
// must be called in:
// slave rx event callback
// or after requestFrom(address, numBytes)
int TwoWire::read(void)
{
  int value = -1;
     6d0:	2f ef       	ldi	r18, 0xFF	; 255
     6d2:	3f ef       	ldi	r19, 0xFF	; 255
  
  // get each successive byte on each call
  if(rxBufferIndex < rxBufferLength){
     6d4:	98 17       	cp	r25, r24
     6d6:	48 f4       	brcc	.+18     	; 0x6ea <_ZN7TwoWire4readEv+0x22>
    value = rxBuffer[rxBufferIndex];
     6d8:	e9 2f       	mov	r30, r25
     6da:	f0 e0       	ldi	r31, 0x00	; 0
     6dc:	ec 51       	subi	r30, 0x1C	; 28
     6de:	fe 4f       	sbci	r31, 0xFE	; 254
     6e0:	20 81       	ld	r18, Z
     6e2:	30 e0       	ldi	r19, 0x00	; 0
    ++rxBufferIndex;
     6e4:	9f 5f       	subi	r25, 0xFF	; 255
     6e6:	90 93 7d 02 	sts	0x027D, r25	; 0x80027d <_ZN7TwoWire13rxBufferIndexE>
  }

  return value;
}
     6ea:	c9 01       	movw	r24, r18
     6ec:	08 95       	ret

000006ee <_ZN7TwoWire9availableEv>:
// must be called in:
// slave rx event callback
// or after requestFrom(address, numBytes)
int TwoWire::available(void)
{
  return rxBufferLength - rxBufferIndex;
     6ee:	80 91 7c 02 	lds	r24, 0x027C	; 0x80027c <_ZN7TwoWire14rxBufferLengthE>
     6f2:	90 91 7d 02 	lds	r25, 0x027D	; 0x80027d <_ZN7TwoWire13rxBufferIndexE>
}
     6f6:	89 1b       	sub	r24, r25
     6f8:	99 0b       	sbc	r25, r25
     6fa:	08 95       	ret

000006fc <_ZN7TwoWire5writeEPKhj>:

// must be called in:
// slave tx event callback
// or after beginTransmission(address)
size_t TwoWire::write(const uint8_t *data, size_t quantity)
{
     6fc:	cf 92       	push	r12
     6fe:	df 92       	push	r13
     700:	ef 92       	push	r14
     702:	ff 92       	push	r15
     704:	0f 93       	push	r16
     706:	1f 93       	push	r17
     708:	cf 93       	push	r28
     70a:	df 93       	push	r29
     70c:	7c 01       	movw	r14, r24
     70e:	cb 01       	movw	r24, r22
     710:	8a 01       	movw	r16, r20
  if(transmitting){
     712:	20 91 85 02 	lds	r18, 0x0285	; 0x800285 <_ZN7TwoWire12transmittingE>
     716:	22 23       	and	r18, r18
     718:	89 f0       	breq	.+34     	; 0x73c <_ZN7TwoWire5writeEPKhj+0x40>
     71a:	eb 01       	movw	r28, r22
     71c:	6b 01       	movw	r12, r22
     71e:	c4 0e       	add	r12, r20
     720:	d5 1e       	adc	r13, r21
  // in master transmitter mode
    for(size_t i = 0; i < quantity; ++i){
     722:	cc 15       	cp	r28, r12
     724:	dd 05       	cpc	r29, r13
     726:	69 f0       	breq	.+26     	; 0x742 <_ZN7TwoWire5writeEPKhj+0x46>
      write(data[i]);
     728:	69 91       	ld	r22, Y+
     72a:	d7 01       	movw	r26, r14
     72c:	ed 91       	ld	r30, X+
     72e:	fc 91       	ld	r31, X
     730:	01 90       	ld	r0, Z+
     732:	f0 81       	ld	r31, Z
     734:	e0 2d       	mov	r30, r0
     736:	c7 01       	movw	r24, r14
     738:	09 95       	icall
     73a:	f3 cf       	rjmp	.-26     	; 0x722 <_ZN7TwoWire5writeEPKhj+0x26>
    }
  }else{
  // in slave send mode
    // reply to master
    twi_transmit(data, quantity);
     73c:	64 2f       	mov	r22, r20
     73e:	0e 94 2d 03 	call	0x65a	; 0x65a <twi_transmit>
  }
  return quantity;
}
     742:	c8 01       	movw	r24, r16
     744:	df 91       	pop	r29
     746:	cf 91       	pop	r28
     748:	1f 91       	pop	r17
     74a:	0f 91       	pop	r16
     74c:	ff 90       	pop	r15
     74e:	ef 90       	pop	r14
     750:	df 90       	pop	r13
     752:	cf 90       	pop	r12
     754:	08 95       	ret

00000756 <_ZN7TwoWire5writeEh>:

// must be called in:
// slave tx event callback
// or after beginTransmission(address)
size_t TwoWire::write(uint8_t data)
{
     756:	cf 93       	push	r28
     758:	df 93       	push	r29
     75a:	1f 92       	push	r1
     75c:	cd b7       	in	r28, 0x3d	; 61
     75e:	de b7       	in	r29, 0x3e	; 62
     760:	69 83       	std	Y+1, r22	; 0x01
  if(transmitting){
     762:	20 91 85 02 	lds	r18, 0x0285	; 0x800285 <_ZN7TwoWire12transmittingE>
     766:	22 23       	and	r18, r18
     768:	f9 f0       	breq	.+62     	; 0x7a8 <_ZN7TwoWire5writeEh+0x52>
  // in master transmitter mode
    // don't bother if buffer is full
    if(txBufferLength >= BUFFER_LENGTH){
     76a:	20 91 82 02 	lds	r18, 0x0282	; 0x800282 <_ZN7TwoWire14txBufferLengthE>
     76e:	20 32       	cpi	r18, 0x20	; 32
     770:	58 f0       	brcs	.+22     	; 0x788 <_ZN7TwoWire5writeEh+0x32>
  private:
    int write_error;
    size_t printNumber(unsigned long, uint8_t);
    size_t printFloat(double, uint8_t);
  protected:
    void setWriteError(int err = 1) { write_error = err; }
     772:	21 e0       	ldi	r18, 0x01	; 1
     774:	30 e0       	ldi	r19, 0x00	; 0
     776:	fc 01       	movw	r30, r24
     778:	33 83       	std	Z+3, r19	; 0x03
     77a:	22 83       	std	Z+2, r18	; 0x02
      setWriteError();
      return 0;
     77c:	90 e0       	ldi	r25, 0x00	; 0
     77e:	80 e0       	ldi	r24, 0x00	; 0
  // in slave send mode
    // reply to master
    twi_transmit(&data, 1);
  }
  return 1;
}
     780:	0f 90       	pop	r0
     782:	df 91       	pop	r29
     784:	cf 91       	pop	r28
     786:	08 95       	ret
    if(txBufferLength >= BUFFER_LENGTH){
      setWriteError();
      return 0;
    }
    // put byte in tx buffer
    txBuffer[txBufferIndex] = data;
     788:	80 91 83 02 	lds	r24, 0x0283	; 0x800283 <_ZN7TwoWire13txBufferIndexE>
     78c:	e8 2f       	mov	r30, r24
     78e:	f0 e0       	ldi	r31, 0x00	; 0
     790:	ec 53       	subi	r30, 0x3C	; 60
     792:	fe 4f       	sbci	r31, 0xFE	; 254
     794:	99 81       	ldd	r25, Y+1	; 0x01
     796:	90 83       	st	Z, r25
    ++txBufferIndex;
     798:	8f 5f       	subi	r24, 0xFF	; 255
     79a:	80 93 83 02 	sts	0x0283, r24	; 0x800283 <_ZN7TwoWire13txBufferIndexE>
    // update amount in buffer   
    txBufferLength = txBufferIndex;
     79e:	80 93 82 02 	sts	0x0282, r24	; 0x800282 <_ZN7TwoWire14txBufferLengthE>
  }else{
  // in slave send mode
    // reply to master
    twi_transmit(&data, 1);
  }
  return 1;
     7a2:	81 e0       	ldi	r24, 0x01	; 1
     7a4:	90 e0       	ldi	r25, 0x00	; 0
     7a6:	ec cf       	rjmp	.-40     	; 0x780 <_ZN7TwoWire5writeEh+0x2a>
    // update amount in buffer   
    txBufferLength = txBufferIndex;
  }else{
  // in slave send mode
    // reply to master
    twi_transmit(&data, 1);
     7a8:	61 e0       	ldi	r22, 0x01	; 1
     7aa:	ce 01       	movw	r24, r28
     7ac:	01 96       	adiw	r24, 0x01	; 1
     7ae:	0e 94 2d 03 	call	0x65a	; 0x65a <twi_transmit>
     7b2:	f7 cf       	rjmp	.-18     	; 0x7a2 <_ZN7TwoWire5writeEh+0x4c>

000007b4 <_ZN7TwoWire15endTransmissionEv>:
//	devices will behave oddly if they do not see a STOP.
//
uint8_t TwoWire::endTransmission(uint8_t sendStop)
{
  // transmit buffer (blocking)
  uint8_t ret = twi_writeTo(txAddress, txBuffer, txBufferLength, 1, sendStop);
     7b4:	20 91 82 02 	lds	r18, 0x0282	; 0x800282 <_ZN7TwoWire14txBufferLengthE>
{
  uint8_t i;

  // ensure data will fit into buffer
  if(TWI_BUFFER_LENGTH < length){
    return 1;
     7b8:	81 e0       	ldi	r24, 0x01	; 1
uint8_t twi_writeTo(uint8_t address, uint8_t* data, uint8_t length, uint8_t wait, uint8_t sendStop)
{
  uint8_t i;

  // ensure data will fit into buffer
  if(TWI_BUFFER_LENGTH < length){
     7ba:	21 32       	cpi	r18, 0x21	; 33
     7bc:	08 f0       	brcs	.+2      	; 0x7c0 <_ZN7TwoWire15endTransmissionEv+0xc>
     7be:	44 c0       	rjmp	.+136    	; 0x848 <_ZN7TwoWire15endTransmissionEv+0x94>
    return 1;
  }

  // wait until twi is ready, become master transmitter
  while(TWI_READY != twi_state){
     7c0:	80 91 7b 02 	lds	r24, 0x027B	; 0x80027b <twi_state>
     7c4:	81 11       	cpse	r24, r1
     7c6:	fc cf       	rjmp	.-8      	; 0x7c0 <_ZN7TwoWire15endTransmissionEv+0xc>
     7c8:	80 91 84 02 	lds	r24, 0x0284	; 0x800284 <_ZN7TwoWire9txAddressE>
    continue;
  }
  twi_state = TWI_MTX;
     7cc:	92 e0       	ldi	r25, 0x02	; 2
     7ce:	90 93 7b 02 	sts	0x027B, r25	; 0x80027b <twi_state>
  twi_sendStop = sendStop;
     7d2:	91 e0       	ldi	r25, 0x01	; 1
     7d4:	90 93 7a 02 	sts	0x027A, r25	; 0x80027a <twi_sendStop>
  // reset error state (0xFF.. no error occured)
  twi_error = 0xFF;
     7d8:	9f ef       	ldi	r25, 0xFF	; 255
     7da:	90 93 47 02 	sts	0x0247, r25	; 0x800247 <twi_error>

  // initialize buffer iteration vars
  twi_masterBufferIndex = 0;
     7de:	10 92 69 02 	sts	0x0269, r1	; 0x800269 <twi_masterBufferIndex>
  twi_masterBufferLength = length;
     7e2:	20 93 68 02 	sts	0x0268, r18	; 0x800268 <twi_masterBufferLength>
     7e6:	a4 ec       	ldi	r26, 0xC4	; 196
     7e8:	b1 e0       	ldi	r27, 0x01	; 1
     7ea:	e8 e4       	ldi	r30, 0x48	; 72
     7ec:	f2 e0       	ldi	r31, 0x02	; 2
  
  // copy data to twi buffer
  for(i = 0; i < length; ++i){
     7ee:	90 e0       	ldi	r25, 0x00	; 0
     7f0:	29 13       	cpse	r18, r25
     7f2:	31 c0       	rjmp	.+98     	; 0x856 <_ZN7TwoWire15endTransmissionEv+0xa2>
    twi_masterBuffer[i] = data[i];
  }
  
  // build sla+w, slave device address + w bit
  twi_slarw = TW_WRITE;
     7f4:	10 92 6a 02 	sts	0x026A, r1	; 0x80026a <twi_slarw>
  twi_slarw |= address << 1;
     7f8:	90 91 6a 02 	lds	r25, 0x026A	; 0x80026a <twi_slarw>
     7fc:	88 0f       	add	r24, r24
     7fe:	89 2b       	or	r24, r25
     800:	80 93 6a 02 	sts	0x026A, r24	; 0x80026a <twi_slarw>
  
  // if we're in a repeated start, then we've already sent the START
  // in the ISR. Don't do it again.
  //
  if (true == twi_inRepStart) {
     804:	80 91 79 02 	lds	r24, 0x0279	; 0x800279 <twi_inRepStart>
     808:	81 30       	cpi	r24, 0x01	; 1
     80a:	49 f5       	brne	.+82     	; 0x85e <_ZN7TwoWire15endTransmissionEv+0xaa>
    // (@@@ we hope), and the TWI statemachine is just waiting for the address byte.
    // We need to remove ourselves from the repeated start state before we enable interrupts,
    // since the ISR is ASYNC, and we could get confused if we hit the ISR before cleaning
    // up. Also, don't enable the START interrupt. There may be one pending from the 
    // repeated start that we sent outselves, and that would really confuse things.
    twi_inRepStart = false;			// remember, we're dealing with an ASYNC ISR
     80c:	10 92 79 02 	sts	0x0279, r1	; 0x800279 <twi_inRepStart>
    do {
      TWDR = twi_slarw;				
     810:	80 91 6a 02 	lds	r24, 0x026A	; 0x80026a <twi_slarw>
     814:	80 93 bb 00 	sts	0x00BB, r24	; 0x8000bb <__TEXT_REGION_LENGTH__+0x7e00bb>
    } while(TWCR & _BV(TWWC));
     818:	80 91 bc 00 	lds	r24, 0x00BC	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>
     81c:	83 fd       	sbrc	r24, 3
     81e:	f8 cf       	rjmp	.-16     	; 0x810 <_ZN7TwoWire15endTransmissionEv+0x5c>
    TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE);	// enable INTs, but not START
     820:	85 ec       	ldi	r24, 0xC5	; 197
  }
  else
    // send start condition
    TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE) | _BV(TWSTA);	// enable INTs
     822:	80 93 bc 00 	sts	0x00BC, r24	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>

  // wait for write operation to complete
  while(wait && (TWI_MTX == twi_state)){
     826:	80 91 7b 02 	lds	r24, 0x027B	; 0x80027b <twi_state>
     82a:	82 30       	cpi	r24, 0x02	; 2
     82c:	e1 f3       	breq	.-8      	; 0x826 <_ZN7TwoWire15endTransmissionEv+0x72>
    continue;
  }
  
  if (twi_error == 0xFF)
     82e:	80 91 47 02 	lds	r24, 0x0247	; 0x800247 <twi_error>
     832:	8f 3f       	cpi	r24, 0xFF	; 255
     834:	b1 f0       	breq	.+44     	; 0x862 <_ZN7TwoWire15endTransmissionEv+0xae>
    return 0;	// success
  else if (twi_error == TW_MT_SLA_NACK)
     836:	80 91 47 02 	lds	r24, 0x0247	; 0x800247 <twi_error>
     83a:	80 32       	cpi	r24, 0x20	; 32
     83c:	a1 f0       	breq	.+40     	; 0x866 <_ZN7TwoWire15endTransmissionEv+0xb2>
    return 2;	// error: address send, nack received
  else if (twi_error == TW_MT_DATA_NACK)
     83e:	80 91 47 02 	lds	r24, 0x0247	; 0x800247 <twi_error>
     842:	80 33       	cpi	r24, 0x30	; 48
     844:	91 f0       	breq	.+36     	; 0x86a <_ZN7TwoWire15endTransmissionEv+0xb6>
    return 3;	// error: data send, nack received
  else
    return 4;	// other twi error
     846:	84 e0       	ldi	r24, 0x04	; 4
  // reset tx buffer iterator vars
  txBufferIndex = 0;
     848:	10 92 83 02 	sts	0x0283, r1	; 0x800283 <_ZN7TwoWire13txBufferIndexE>
  txBufferLength = 0;
     84c:	10 92 82 02 	sts	0x0282, r1	; 0x800282 <_ZN7TwoWire14txBufferLengthE>
  // indicate that we are done transmitting
  transmitting = 0;
     850:	10 92 85 02 	sts	0x0285, r1	; 0x800285 <_ZN7TwoWire12transmittingE>
//	definition, and expected behaviour, of endTransmission
//
uint8_t TwoWire::endTransmission(void)
{
  return endTransmission(true);
}
     854:	08 95       	ret
  twi_masterBufferIndex = 0;
  twi_masterBufferLength = length;
  
  // copy data to twi buffer
  for(i = 0; i < length; ++i){
    twi_masterBuffer[i] = data[i];
     856:	3d 91       	ld	r19, X+
     858:	31 93       	st	Z+, r19
  // initialize buffer iteration vars
  twi_masterBufferIndex = 0;
  twi_masterBufferLength = length;
  
  // copy data to twi buffer
  for(i = 0; i < length; ++i){
     85a:	9f 5f       	subi	r25, 0xFF	; 255
     85c:	c9 cf       	rjmp	.-110    	; 0x7f0 <_ZN7TwoWire15endTransmissionEv+0x3c>
    } while(TWCR & _BV(TWWC));
    TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE);	// enable INTs, but not START
  }
  else
    // send start condition
    TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE) | _BV(TWSTA);	// enable INTs
     85e:	85 ee       	ldi	r24, 0xE5	; 229
     860:	e0 cf       	rjmp	.-64     	; 0x822 <_ZN7TwoWire15endTransmissionEv+0x6e>
  while(wait && (TWI_MTX == twi_state)){
    continue;
  }
  
  if (twi_error == 0xFF)
    return 0;	// success
     862:	80 e0       	ldi	r24, 0x00	; 0
     864:	f1 cf       	rjmp	.-30     	; 0x848 <_ZN7TwoWire15endTransmissionEv+0x94>
  else if (twi_error == TW_MT_SLA_NACK)
    return 2;	// error: address send, nack received
     866:	82 e0       	ldi	r24, 0x02	; 2
     868:	ef cf       	rjmp	.-34     	; 0x848 <_ZN7TwoWire15endTransmissionEv+0x94>
  else if (twi_error == TW_MT_DATA_NACK)
    return 3;	// error: data send, nack received
     86a:	83 e0       	ldi	r24, 0x03	; 3
     86c:	ed cf       	rjmp	.-38     	; 0x848 <_ZN7TwoWire15endTransmissionEv+0x94>

0000086e <_ZN15Adafruit_BME2806write8Ehh.constprop.40>:
    @brief  Writes an 8 bit value over I2C or SPI
    @param reg the register address to write to
    @param value the value to write to the register
*/
/**************************************************************************/
void Adafruit_BME280::write8(byte reg, byte value) {
     86e:	cf 93       	push	r28
     870:	df 93       	push	r29
     872:	d8 2f       	mov	r29, r24
     874:	c6 2f       	mov	r28, r22
    if (_cs == -1) {
     876:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     87a:	8f 3f       	cpi	r24, 0xFF	; 255
     87c:	59 f5       	brne	.+86     	; 0x8d4 <_ZN15Adafruit_BME2806write8Ehh.constprop.40+0x66>
        _wire -> beginTransmission((uint8_t)_i2caddr);
     87e:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     882:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     886:	20 91 31 03 	lds	r18, 0x0331	; 0x800331 <bme+0x2>
}

void TwoWire::beginTransmission(uint8_t address)
{
  // indicate that we are transmitting
  transmitting = 1;
     88a:	31 e0       	ldi	r19, 0x01	; 1
     88c:	30 93 85 02 	sts	0x0285, r19	; 0x800285 <_ZN7TwoWire12transmittingE>
  // set address of targeted slave
  txAddress = address;
     890:	20 93 84 02 	sts	0x0284, r18	; 0x800284 <_ZN7TwoWire9txAddressE>
  // reset tx buffer iterator vars
  txBufferIndex = 0;
     894:	10 92 83 02 	sts	0x0283, r1	; 0x800283 <_ZN7TwoWire13txBufferIndexE>
  txBufferLength = 0;
     898:	10 92 82 02 	sts	0x0282, r1	; 0x800282 <_ZN7TwoWire14txBufferLengthE>
        _wire -> write((uint8_t)reg);
     89c:	dc 01       	movw	r26, r24
     89e:	ed 91       	ld	r30, X+
     8a0:	fc 91       	ld	r31, X
     8a2:	01 90       	ld	r0, Z+
     8a4:	f0 81       	ld	r31, Z
     8a6:	e0 2d       	mov	r30, r0
     8a8:	6d 2f       	mov	r22, r29
     8aa:	09 95       	icall
        _wire -> write((uint8_t)value);
     8ac:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     8b0:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     8b4:	dc 01       	movw	r26, r24
     8b6:	ed 91       	ld	r30, X+
     8b8:	fc 91       	ld	r31, X
     8ba:	01 90       	ld	r0, Z+
     8bc:	f0 81       	ld	r31, Z
     8be:	e0 2d       	mov	r30, r0
     8c0:	6c 2f       	mov	r22, r28
     8c2:	09 95       	icall
        _wire -> endTransmission();
     8c4:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     8c8:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
        spixfer(value);
        digitalWrite(_cs, HIGH);
    if (_sck == -1)
        SPI.endTransaction(); // release the SPI bus
    }
}
     8cc:	df 91       	pop	r29
     8ce:	cf 91       	pop	r28
void Adafruit_BME280::write8(byte reg, byte value) {
    if (_cs == -1) {
        _wire -> beginTransmission((uint8_t)_i2caddr);
        _wire -> write((uint8_t)reg);
        _wire -> write((uint8_t)value);
        _wire -> endTransmission();
     8d0:	0c 94 da 03 	jmp	0x7b4	; 0x7b4 <_ZN7TwoWire15endTransmissionEv>
    } else {
        if (_sck == -1)
     8d4:	80 91 3d 03 	lds	r24, 0x033D	; 0x80033d <bme+0xe>
     8d8:	8f 3f       	cpi	r24, 0xFF	; 255
     8da:	21 f4       	brne	.+8      	; 0x8e4 <_ZN15Adafruit_BME2806write8Ehh.constprop.40+0x76>
            SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
     8dc:	82 e5       	ldi	r24, 0x52	; 82
     8de:	91 e0       	ldi	r25, 0x01	; 1
     8e0:	0e 94 d3 00 	call	0x1a6	; 0x1a6 <_ZN8SPIClass16beginTransactionE11SPISettings.constprop.46>
        digitalWrite(_cs, LOW);
     8e4:	60 e0       	ldi	r22, 0x00	; 0
     8e6:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     8ea:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
        spixfer(reg & ~0x80); // write, bit 7 low
     8ee:	8d 2f       	mov	r24, r29
     8f0:	8f 77       	andi	r24, 0x7F	; 127
     8f2:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
        spixfer(value);
     8f6:	8c 2f       	mov	r24, r28
     8f8:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
        digitalWrite(_cs, HIGH);
     8fc:	61 e0       	ldi	r22, 0x01	; 1
     8fe:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
    if (_sck == -1)
        SPI.endTransaction(); // release the SPI bus
    }
}
     902:	df 91       	pop	r29
     904:	cf 91       	pop	r28
        if (_sck == -1)
            SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
        digitalWrite(_cs, LOW);
        spixfer(reg & ~0x80); // write, bit 7 low
        spixfer(value);
        digitalWrite(_cs, HIGH);
     906:	0c 94 0e 02 	jmp	0x41c	; 0x41c <digitalWrite>

0000090a <_ZN5Print17availableForWriteEv>:
      return write((const uint8_t *)buffer, size);
    }

    // default to zero, meaning "a single write may block"
    // should be overriden by subclasses with buffering
    virtual int availableForWrite() { return 0; }
     90a:	90 e0       	ldi	r25, 0x00	; 0
     90c:	80 e0       	ldi	r24, 0x00	; 0
     90e:	08 95       	ret

00000910 <_ZN5Print5writeEPKc.part.2.constprop.52>:
    void clearWriteError() { setWriteError(0); }
  
    virtual size_t write(uint8_t) = 0;
    size_t write(const char *str) {
      if (str == NULL) return 0;
      return write((const uint8_t *)str, strlen(str));
     910:	fc 01       	movw	r30, r24
     912:	01 90       	ld	r0, Z+
     914:	00 20       	and	r0, r0
     916:	e9 f7       	brne	.-6      	; 0x912 <_ZN5Print5writeEPKc.part.2.constprop.52+0x2>
     918:	31 97       	sbiw	r30, 0x01	; 1
     91a:	af 01       	movw	r20, r30
     91c:	48 1b       	sub	r20, r24
     91e:	59 0b       	sbc	r21, r25
     920:	bc 01       	movw	r22, r24
     922:	86 e8       	ldi	r24, 0x86	; 134
     924:	92 e0       	ldi	r25, 0x02	; 2
     926:	0c 94 d8 00 	jmp	0x1b0	; 0x1b0 <_ZN5Print5writeEPKhj>

0000092a <_ZN5Print11printNumberEmh.constprop.17>:
  return n;
}

// Private Methods /////////////////////////////////////////////////////////////

size_t Print::printNumber(unsigned long n, uint8_t base)
     92a:	8f 92       	push	r8
     92c:	9f 92       	push	r9
     92e:	af 92       	push	r10
     930:	bf 92       	push	r11
     932:	0f 93       	push	r16
     934:	1f 93       	push	r17
     936:	cf 93       	push	r28
     938:	df 93       	push	r29
     93a:	cd b7       	in	r28, 0x3d	; 61
     93c:	de b7       	in	r29, 0x3e	; 62
     93e:	a1 97       	sbiw	r28, 0x21	; 33
     940:	0f b6       	in	r0, 0x3f	; 63
     942:	f8 94       	cli
     944:	de bf       	out	0x3e, r29	; 62
     946:	0f be       	out	0x3f, r0	; 63
     948:	cd bf       	out	0x3d, r28	; 61
{
  char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
  char *str = &buf[sizeof(buf) - 1];

  *str = '\0';
     94a:	19 a2       	std	Y+33, r1	; 0x21

  // prevent crash if called with base == 1
  if (base < 2) base = 10;
     94c:	42 30       	cpi	r20, 0x02	; 2
     94e:	08 f4       	brcc	.+2      	; 0x952 <_ZN5Print11printNumberEmh.constprop.17+0x28>
     950:	4a e0       	ldi	r20, 0x0A	; 10
     952:	8e 01       	movw	r16, r28
     954:	0f 5d       	subi	r16, 0xDF	; 223
     956:	1f 4f       	sbci	r17, 0xFF	; 255

  do {
    char c = n % base;
     958:	84 2e       	mov	r8, r20
     95a:	91 2c       	mov	r9, r1
     95c:	b1 2c       	mov	r11, r1
     95e:	a1 2c       	mov	r10, r1
     960:	a5 01       	movw	r20, r10
     962:	94 01       	movw	r18, r8
     964:	0e 94 9f 13 	call	0x273e	; 0x273e <__udivmodsi4>
     968:	e6 2f       	mov	r30, r22
    n /= base;
     96a:	b9 01       	movw	r22, r18
     96c:	ca 01       	movw	r24, r20

    *--str = c < 10 ? c + '0' : c + 'A' - 10;
     96e:	ea 30       	cpi	r30, 0x0A	; 10
     970:	f4 f4       	brge	.+60     	; 0x9ae <_ZN5Print11printNumberEmh.constprop.17+0x84>
     972:	e0 5d       	subi	r30, 0xD0	; 208
     974:	d8 01       	movw	r26, r16
     976:	ee 93       	st	-X, r30
     978:	8d 01       	movw	r16, r26
  } while(n);
     97a:	23 2b       	or	r18, r19
     97c:	24 2b       	or	r18, r20
     97e:	25 2b       	or	r18, r21
     980:	79 f7       	brne	.-34     	; 0x960 <_ZN5Print11printNumberEmh.constprop.17+0x36>
    int getWriteError() { return write_error; }
    void clearWriteError() { setWriteError(0); }
  
    virtual size_t write(uint8_t) = 0;
    size_t write(const char *str) {
      if (str == NULL) return 0;
     982:	90 e0       	ldi	r25, 0x00	; 0
     984:	80 e0       	ldi	r24, 0x00	; 0
     986:	10 97       	sbiw	r26, 0x00	; 0
     988:	19 f0       	breq	.+6      	; 0x990 <_ZN5Print11printNumberEmh.constprop.17+0x66>
     98a:	cd 01       	movw	r24, r26
     98c:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>

  return write(str);
}
     990:	a1 96       	adiw	r28, 0x21	; 33
     992:	0f b6       	in	r0, 0x3f	; 63
     994:	f8 94       	cli
     996:	de bf       	out	0x3e, r29	; 62
     998:	0f be       	out	0x3f, r0	; 63
     99a:	cd bf       	out	0x3d, r28	; 61
     99c:	df 91       	pop	r29
     99e:	cf 91       	pop	r28
     9a0:	1f 91       	pop	r17
     9a2:	0f 91       	pop	r16
     9a4:	bf 90       	pop	r11
     9a6:	af 90       	pop	r10
     9a8:	9f 90       	pop	r9
     9aa:	8f 90       	pop	r8
     9ac:	08 95       	ret

  do {
    char c = n % base;
    n /= base;

    *--str = c < 10 ? c + '0' : c + 'A' - 10;
     9ae:	e9 5c       	subi	r30, 0xC9	; 201
     9b0:	e1 cf       	rjmp	.-62     	; 0x974 <_ZN5Print11printNumberEmh.constprop.17+0x4a>

000009b2 <_ZN5Print7printlnEPKc.constprop.49>:
  size_t n = print(s);
  n += println();
  return n;
}

size_t Print::println(const char c[])
     9b2:	cf 93       	push	r28
     9b4:	df 93       	push	r29
     9b6:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>
     9ba:	ec 01       	movw	r28, r24
     9bc:	84 e2       	ldi	r24, 0x24	; 36
     9be:	91 e0       	ldi	r25, 0x01	; 1
     9c0:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>
{
  size_t n = print(c);
  n += println();
  return n;
}
     9c4:	8c 0f       	add	r24, r28
     9c6:	9d 1f       	adc	r25, r29
     9c8:	df 91       	pop	r29
     9ca:	cf 91       	pop	r28
     9cc:	08 95       	ret

000009ce <_ZN5Print10printFloatEdh.constprop.12>:
  } while(n);

  return write(str);
}

size_t Print::printFloat(double number, uint8_t digits) 
     9ce:	4f 92       	push	r4
     9d0:	5f 92       	push	r5
     9d2:	6f 92       	push	r6
     9d4:	7f 92       	push	r7
     9d6:	8f 92       	push	r8
     9d8:	9f 92       	push	r9
     9da:	af 92       	push	r10
     9dc:	bf 92       	push	r11
     9de:	cf 92       	push	r12
     9e0:	df 92       	push	r13
     9e2:	ef 92       	push	r14
     9e4:	ff 92       	push	r15
     9e6:	0f 93       	push	r16
     9e8:	1f 93       	push	r17
     9ea:	cf 93       	push	r28
     9ec:	6b 01       	movw	r12, r22
     9ee:	7c 01       	movw	r14, r24
     9f0:	74 2e       	mov	r7, r20
{ 
  size_t n = 0;
  
  if (isnan(number)) return print("nan");
     9f2:	ac 01       	movw	r20, r24
     9f4:	9b 01       	movw	r18, r22
     9f6:	0e 94 55 12 	call	0x24aa	; 0x24aa <__unordsf2>
     9fa:	88 23       	and	r24, r24
     9fc:	99 f0       	breq	.+38     	; 0xa24 <_ZN5Print10printFloatEdh.constprop.12+0x56>
     9fe:	87 e2       	ldi	r24, 0x27	; 39
     a00:	91 e0       	ldi	r25, 0x01	; 1
    n += print(toPrint);
    remainder -= toPrint; 
  } 
  
  return n;
}
     a02:	cf 91       	pop	r28
     a04:	1f 91       	pop	r17
     a06:	0f 91       	pop	r16
     a08:	ff 90       	pop	r15
     a0a:	ef 90       	pop	r14
     a0c:	df 90       	pop	r13
     a0e:	cf 90       	pop	r12
     a10:	bf 90       	pop	r11
     a12:	af 90       	pop	r10
     a14:	9f 90       	pop	r9
     a16:	8f 90       	pop	r8
     a18:	7f 90       	pop	r7
     a1a:	6f 90       	pop	r6
     a1c:	5f 90       	pop	r5
     a1e:	4f 90       	pop	r4
     a20:	0c 94 88 04 	jmp	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>
size_t Print::printFloat(double number, uint8_t digits) 
{ 
  size_t n = 0;
  
  if (isnan(number)) return print("nan");
  if (isinf(number)) return print("inf");
     a24:	46 01       	movw	r8, r12
     a26:	57 01       	movw	r10, r14
     a28:	e8 94       	clt
     a2a:	b7 f8       	bld	r11, 7
     a2c:	2f ef       	ldi	r18, 0xFF	; 255
     a2e:	3f ef       	ldi	r19, 0xFF	; 255
     a30:	4f e7       	ldi	r20, 0x7F	; 127
     a32:	5f e7       	ldi	r21, 0x7F	; 127
     a34:	c5 01       	movw	r24, r10
     a36:	b4 01       	movw	r22, r8
     a38:	0e 94 55 12 	call	0x24aa	; 0x24aa <__unordsf2>
     a3c:	81 11       	cpse	r24, r1
     a3e:	0d c0       	rjmp	.+26     	; 0xa5a <_ZN5Print10printFloatEdh.constprop.12+0x8c>
     a40:	2f ef       	ldi	r18, 0xFF	; 255
     a42:	3f ef       	ldi	r19, 0xFF	; 255
     a44:	4f e7       	ldi	r20, 0x7F	; 127
     a46:	5f e7       	ldi	r21, 0x7F	; 127
     a48:	c5 01       	movw	r24, r10
     a4a:	b4 01       	movw	r22, r8
     a4c:	0e 94 e7 0f 	call	0x1fce	; 0x1fce <__cmpsf2>
     a50:	18 16       	cp	r1, r24
     a52:	1c f4       	brge	.+6      	; 0xa5a <_ZN5Print10printFloatEdh.constprop.12+0x8c>
     a54:	8b e2       	ldi	r24, 0x2B	; 43
     a56:	91 e0       	ldi	r25, 0x01	; 1
     a58:	d4 cf       	rjmp	.-88     	; 0xa02 <_ZN5Print10printFloatEdh.constprop.12+0x34>
  if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
     a5a:	2f ef       	ldi	r18, 0xFF	; 255
     a5c:	3f ef       	ldi	r19, 0xFF	; 255
     a5e:	4f e7       	ldi	r20, 0x7F	; 127
     a60:	5f e4       	ldi	r21, 0x4F	; 79
     a62:	c7 01       	movw	r24, r14
     a64:	b6 01       	movw	r22, r12
     a66:	0e 94 93 11 	call	0x2326	; 0x2326 <__gesf2>
     a6a:	18 16       	cp	r1, r24
     a6c:	1c f4       	brge	.+6      	; 0xa74 <_ZN5Print10printFloatEdh.constprop.12+0xa6>
     a6e:	8f e2       	ldi	r24, 0x2F	; 47
     a70:	91 e0       	ldi	r25, 0x01	; 1
     a72:	c7 cf       	rjmp	.-114    	; 0xa02 <_ZN5Print10printFloatEdh.constprop.12+0x34>
  if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
     a74:	2f ef       	ldi	r18, 0xFF	; 255
     a76:	3f ef       	ldi	r19, 0xFF	; 255
     a78:	4f e7       	ldi	r20, 0x7F	; 127
     a7a:	5f ec       	ldi	r21, 0xCF	; 207
     a7c:	c7 01       	movw	r24, r14
     a7e:	b6 01       	movw	r22, r12
     a80:	0e 94 e7 0f 	call	0x1fce	; 0x1fce <__cmpsf2>
     a84:	87 fd       	sbrc	r24, 7
     a86:	f3 cf       	rjmp	.-26     	; 0xa6e <_ZN5Print10printFloatEdh.constprop.12+0xa0>
  
  // Handle negative numbers
  if (number < 0.0)
     a88:	20 e0       	ldi	r18, 0x00	; 0
     a8a:	30 e0       	ldi	r19, 0x00	; 0
     a8c:	a9 01       	movw	r20, r18
     a8e:	c7 01       	movw	r24, r14
     a90:	b6 01       	movw	r22, r12
     a92:	0e 94 e7 0f 	call	0x1fce	; 0x1fce <__cmpsf2>
  return write(str);
}

size_t Print::printFloat(double number, uint8_t digits) 
{ 
  size_t n = 0;
     a96:	10 e0       	ldi	r17, 0x00	; 0
     a98:	00 e0       	ldi	r16, 0x00	; 0
  if (isinf(number)) return print("inf");
  if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
  if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
  
  // Handle negative numbers
  if (number < 0.0)
     a9a:	87 ff       	sbrs	r24, 7
     a9c:	0a c0       	rjmp	.+20     	; 0xab2 <_ZN5Print10printFloatEdh.constprop.12+0xe4>
  return write(str);
}

size_t Print::print(char c)
{
  return write(c);
     a9e:	6d e2       	ldi	r22, 0x2D	; 45
     aa0:	86 e8       	ldi	r24, 0x86	; 134
     aa2:	92 e0       	ldi	r25, 0x02	; 2
     aa4:	0e 94 78 01 	call	0x2f0	; 0x2f0 <_ZN14HardwareSerial5writeEh>
     aa8:	8c 01       	movw	r16, r24
  
  // Handle negative numbers
  if (number < 0.0)
  {
     n += print('-');
     number = -number;
     aaa:	f7 fa       	bst	r15, 7
     aac:	f0 94       	com	r15
     aae:	f7 f8       	bld	r15, 7
     ab0:	f0 94       	com	r15
  }

  // Round correctly so that print(1.999, 2) prints as "2.00"
  double rounding = 0.5;
  for (uint8_t i=0; i<digits; ++i)
     ab2:	c0 e0       	ldi	r28, 0x00	; 0
     n += print('-');
     number = -number;
  }

  // Round correctly so that print(1.999, 2) prints as "2.00"
  double rounding = 0.5;
     ab4:	60 e0       	ldi	r22, 0x00	; 0
     ab6:	70 e0       	ldi	r23, 0x00	; 0
     ab8:	80 e0       	ldi	r24, 0x00	; 0
     aba:	9f e3       	ldi	r25, 0x3F	; 63
  for (uint8_t i=0; i<digits; ++i)
     abc:	7c 16       	cp	r7, r28
     abe:	41 f0       	breq	.+16     	; 0xad0 <_ZN5Print10printFloatEdh.constprop.12+0x102>
    rounding /= 10.0;
     ac0:	20 e0       	ldi	r18, 0x00	; 0
     ac2:	30 e0       	ldi	r19, 0x00	; 0
     ac4:	40 e2       	ldi	r20, 0x20	; 32
     ac6:	51 e4       	ldi	r21, 0x41	; 65
     ac8:	0e 94 ec 0f 	call	0x1fd8	; 0x1fd8 <__divsf3>
     number = -number;
  }

  // Round correctly so that print(1.999, 2) prints as "2.00"
  double rounding = 0.5;
  for (uint8_t i=0; i<digits; ++i)
     acc:	cf 5f       	subi	r28, 0xFF	; 255
     ace:	f6 cf       	rjmp	.-20     	; 0xabc <_ZN5Print10printFloatEdh.constprop.12+0xee>
    rounding /= 10.0;
  
  number += rounding;
     ad0:	a7 01       	movw	r20, r14
     ad2:	96 01       	movw	r18, r12
     ad4:	0e 94 7b 0f 	call	0x1ef6	; 0x1ef6 <__addsf3>
     ad8:	2b 01       	movw	r4, r22
     ada:	3c 01       	movw	r6, r24

  // Extract the integer part of the number and print it
  unsigned long int_part = (unsigned long)number;
     adc:	0e 94 5e 10 	call	0x20bc	; 0x20bc <__fixunssfsi>
     ae0:	4b 01       	movw	r8, r22
     ae2:	5c 01       	movw	r10, r24
}

size_t Print::print(unsigned long n, int base)
{
  if (base == 0) return write(n);
  else return printNumber(n, base);
     ae4:	4a e0       	ldi	r20, 0x0A	; 10
     ae6:	0e 94 95 04 	call	0x92a	; 0x92a <_ZN5Print11printNumberEmh.constprop.17>
  number += rounding;

  // Extract the integer part of the number and print it
  unsigned long int_part = (unsigned long)number;
  double remainder = number - (double)int_part;
  n += print(int_part);
     aea:	7c 01       	movw	r14, r24
     aec:	e0 0e       	add	r14, r16
     aee:	f1 1e       	adc	r15, r17

  // Print the decimal point, but only if there are digits beyond
  if (digits > 0) {
     af0:	cc 23       	and	r28, r28
     af2:	c1 f1       	breq	.+112    	; 0xb64 <_ZN5Print10printFloatEdh.constprop.12+0x196>
  
  number += rounding;

  // Extract the integer part of the number and print it
  unsigned long int_part = (unsigned long)number;
  double remainder = number - (double)int_part;
     af4:	c5 01       	movw	r24, r10
     af6:	b4 01       	movw	r22, r8
     af8:	0e 94 93 10 	call	0x2126	; 0x2126 <__floatunsisf>
     afc:	9b 01       	movw	r18, r22
     afe:	ac 01       	movw	r20, r24
     b00:	c3 01       	movw	r24, r6
     b02:	b2 01       	movw	r22, r4
     b04:	0e 94 7a 0f 	call	0x1ef4	; 0x1ef4 <__subsf3>
     b08:	4b 01       	movw	r8, r22
     b0a:	5c 01       	movw	r10, r24
  return write(str);
}

size_t Print::print(char c)
{
  return write(c);
     b0c:	6e e2       	ldi	r22, 0x2E	; 46
     b0e:	86 e8       	ldi	r24, 0x86	; 134
     b10:	92 e0       	ldi	r25, 0x02	; 2
     b12:	0e 94 78 01 	call	0x2f0	; 0x2f0 <_ZN14HardwareSerial5writeEh>
  double remainder = number - (double)int_part;
  n += print(int_part);

  // Print the decimal point, but only if there are digits beyond
  if (digits > 0) {
    n += print('.'); 
     b16:	e8 0e       	add	r14, r24
     b18:	f9 1e       	adc	r15, r25
  }

  // Extract digits from the remainder one at a time
  while (digits-- > 0)
     b1a:	c1 50       	subi	r28, 0x01	; 1
     b1c:	18 f1       	brcs	.+70     	; 0xb64 <_ZN5Print10printFloatEdh.constprop.12+0x196>
  {
    remainder *= 10.0;
     b1e:	20 e0       	ldi	r18, 0x00	; 0
     b20:	30 e0       	ldi	r19, 0x00	; 0
     b22:	40 e2       	ldi	r20, 0x20	; 32
     b24:	51 e4       	ldi	r21, 0x41	; 65
     b26:	c5 01       	movw	r24, r10
     b28:	b4 01       	movw	r22, r8
     b2a:	0e 94 98 11 	call	0x2330	; 0x2330 <__mulsf3>
     b2e:	2b 01       	movw	r4, r22
     b30:	3c 01       	movw	r6, r24
    unsigned int toPrint = (unsigned int)(remainder);
     b32:	0e 94 5e 10 	call	0x20bc	; 0x20bc <__fixunssfsi>
  return print((long) n, base);
}

size_t Print::print(unsigned int n, int base)
{
  return print((unsigned long) n, base);
     b36:	4b 01       	movw	r8, r22
     b38:	b1 2c       	mov	r11, r1
     b3a:	a1 2c       	mov	r10, r1
}

size_t Print::print(unsigned long n, int base)
{
  if (base == 0) return write(n);
  else return printNumber(n, base);
     b3c:	4a e0       	ldi	r20, 0x0A	; 10
     b3e:	c5 01       	movw	r24, r10
     b40:	b4 01       	movw	r22, r8
     b42:	0e 94 95 04 	call	0x92a	; 0x92a <_ZN5Print11printNumberEmh.constprop.17>
  // Extract digits from the remainder one at a time
  while (digits-- > 0)
  {
    remainder *= 10.0;
    unsigned int toPrint = (unsigned int)(remainder);
    n += print(toPrint);
     b46:	e8 0e       	add	r14, r24
     b48:	f9 1e       	adc	r15, r25
    remainder -= toPrint; 
     b4a:	c5 01       	movw	r24, r10
     b4c:	b4 01       	movw	r22, r8
     b4e:	0e 94 93 10 	call	0x2126	; 0x2126 <__floatunsisf>
     b52:	9b 01       	movw	r18, r22
     b54:	ac 01       	movw	r20, r24
     b56:	c3 01       	movw	r24, r6
     b58:	b2 01       	movw	r22, r4
     b5a:	0e 94 7a 0f 	call	0x1ef4	; 0x1ef4 <__subsf3>
     b5e:	4b 01       	movw	r8, r22
     b60:	5c 01       	movw	r10, r24
     b62:	db cf       	rjmp	.-74     	; 0xb1a <_ZN5Print10printFloatEdh.constprop.12+0x14c>
  } 
  
  return n;
}
     b64:	c7 01       	movw	r24, r14
     b66:	cf 91       	pop	r28
     b68:	1f 91       	pop	r17
     b6a:	0f 91       	pop	r16
     b6c:	ff 90       	pop	r15
     b6e:	ef 90       	pop	r14
     b70:	df 90       	pop	r13
     b72:	cf 90       	pop	r12
     b74:	bf 90       	pop	r11
     b76:	af 90       	pop	r10
     b78:	9f 90       	pop	r9
     b7a:	8f 90       	pop	r8
     b7c:	7f 90       	pop	r7
     b7e:	6f 90       	pop	r6
     b80:	5f 90       	pop	r5
     b82:	4f 90       	pop	r4
     b84:	08 95       	ret

00000b86 <_ZN7TwoWire11requestFromEhh>:
  if(TWI_BUFFER_LENGTH < length){
    return 0;
  }

  // wait until twi is ready, become master receiver
  while(TWI_READY != twi_state){
     b86:	80 91 7b 02 	lds	r24, 0x027B	; 0x80027b <twi_state>
     b8a:	81 11       	cpse	r24, r1
     b8c:	fc cf       	rjmp	.-8      	; 0xb86 <_ZN7TwoWire11requestFromEhh>
    continue;
  }
  twi_state = TWI_MRX;
     b8e:	81 e0       	ldi	r24, 0x01	; 1
     b90:	80 93 7b 02 	sts	0x027B, r24	; 0x80027b <twi_state>
  twi_sendStop = sendStop;
     b94:	80 93 7a 02 	sts	0x027A, r24	; 0x80027a <twi_sendStop>
  // reset error state (0xFF.. no error occured)
  twi_error = 0xFF;
     b98:	9f ef       	ldi	r25, 0xFF	; 255
     b9a:	90 93 47 02 	sts	0x0247, r25	; 0x800247 <twi_error>

  // initialize buffer iteration vars
  twi_masterBufferIndex = 0;
     b9e:	10 92 69 02 	sts	0x0269, r1	; 0x800269 <twi_masterBufferIndex>
  twi_masterBufferLength = length-1;  // This is not intuitive, read on...
     ba2:	94 0f       	add	r25, r20
     ba4:	90 93 68 02 	sts	0x0268, r25	; 0x800268 <twi_masterBufferLength>
  // Therefor we must actually set NACK when the _next_ to last byte is
  // received, causing that NACK to be sent in response to receiving the last
  // expected byte of data.

  // build sla+w, slave device address + w bit
  twi_slarw = TW_READ;
     ba8:	80 93 6a 02 	sts	0x026A, r24	; 0x80026a <twi_slarw>
  twi_slarw |= address << 1;
     bac:	80 91 6a 02 	lds	r24, 0x026A	; 0x80026a <twi_slarw>
     bb0:	66 0f       	add	r22, r22
     bb2:	68 2b       	or	r22, r24
     bb4:	60 93 6a 02 	sts	0x026A, r22	; 0x80026a <twi_slarw>

  if (true == twi_inRepStart) {
     bb8:	80 91 79 02 	lds	r24, 0x0279	; 0x800279 <twi_inRepStart>
     bbc:	81 30       	cpi	r24, 0x01	; 1
     bbe:	19 f5       	brne	.+70     	; 0xc06 <_ZN7TwoWire11requestFromEhh+0x80>
    // (@@@ we hope), and the TWI statemachine is just waiting for the address byte.
    // We need to remove ourselves from the repeated start state before we enable interrupts,
    // since the ISR is ASYNC, and we could get confused if we hit the ISR before cleaning
    // up. Also, don't enable the START interrupt. There may be one pending from the 
    // repeated start that we sent ourselves, and that would really confuse things.
    twi_inRepStart = false;			// remember, we're dealing with an ASYNC ISR
     bc0:	10 92 79 02 	sts	0x0279, r1	; 0x800279 <twi_inRepStart>
    do {
      TWDR = twi_slarw;
     bc4:	80 91 6a 02 	lds	r24, 0x026A	; 0x80026a <twi_slarw>
     bc8:	80 93 bb 00 	sts	0x00BB, r24	; 0x8000bb <__TEXT_REGION_LENGTH__+0x7e00bb>
    } while(TWCR & _BV(TWWC));
     bcc:	80 91 bc 00 	lds	r24, 0x00BC	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>
     bd0:	83 fd       	sbrc	r24, 3
     bd2:	f8 cf       	rjmp	.-16     	; 0xbc4 <_ZN7TwoWire11requestFromEhh+0x3e>
    TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE);	// enable INTs, but not START
     bd4:	85 ec       	ldi	r24, 0xC5	; 197
  }
  else
    // send start condition
    TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTA);
     bd6:	80 93 bc 00 	sts	0x00BC, r24	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>

  // wait for read operation to complete
  while(TWI_MRX == twi_state){
     bda:	80 91 7b 02 	lds	r24, 0x027B	; 0x80027b <twi_state>
     bde:	81 30       	cpi	r24, 0x01	; 1
     be0:	e1 f3       	breq	.-8      	; 0xbda <_ZN7TwoWire11requestFromEhh+0x54>
    continue;
  }

  if (twi_masterBufferIndex < length)
     be2:	80 91 69 02 	lds	r24, 0x0269	; 0x800269 <twi_masterBufferIndex>
     be6:	84 17       	cp	r24, r20
     be8:	10 f4       	brcc	.+4      	; 0xbee <_ZN7TwoWire11requestFromEhh+0x68>
    length = twi_masterBufferIndex;
     bea:	40 91 69 02 	lds	r20, 0x0269	; 0x800269 <twi_masterBufferIndex>
     bee:	a8 e4       	ldi	r26, 0x48	; 72
     bf0:	b2 e0       	ldi	r27, 0x02	; 2
     bf2:	e4 ee       	ldi	r30, 0xE4	; 228
     bf4:	f1 e0       	ldi	r31, 0x01	; 1

  // copy twi buffer to data
  for(i = 0; i < length; ++i){
     bf6:	80 e0       	ldi	r24, 0x00	; 0
     bf8:	84 13       	cpse	r24, r20
     bfa:	07 c0       	rjmp	.+14     	; 0xc0a <_ZN7TwoWire11requestFromEhh+0x84>
    quantity = BUFFER_LENGTH;
  }
  // perform blocking read into buffer
  uint8_t read = twi_readFrom(address, rxBuffer, quantity, sendStop);
  // set rx buffer iterator vars
  rxBufferIndex = 0;
     bfc:	10 92 7d 02 	sts	0x027D, r1	; 0x80027d <_ZN7TwoWire13rxBufferIndexE>
  rxBufferLength = read;
     c00:	80 93 7c 02 	sts	0x027C, r24	; 0x80027c <_ZN7TwoWire14rxBufferLengthE>
}

uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity)
{
  return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)true);
}
     c04:	08 95       	ret
    } while(TWCR & _BV(TWWC));
    TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE);	// enable INTs, but not START
  }
  else
    // send start condition
    TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTA);
     c06:	85 ee       	ldi	r24, 0xE5	; 229
     c08:	e6 cf       	rjmp	.-52     	; 0xbd6 <_ZN7TwoWire11requestFromEhh+0x50>
  if (twi_masterBufferIndex < length)
    length = twi_masterBufferIndex;

  // copy twi buffer to data
  for(i = 0; i < length; ++i){
    data[i] = twi_masterBuffer[i];
     c0a:	9d 91       	ld	r25, X+
     c0c:	91 93       	st	Z+, r25

  if (twi_masterBufferIndex < length)
    length = twi_masterBufferIndex;

  // copy twi buffer to data
  for(i = 0; i < length; ++i){
     c0e:	8f 5f       	subi	r24, 0xFF	; 255
     c10:	f3 cf       	rjmp	.-26     	; 0xbf8 <_ZN7TwoWire11requestFromEhh+0x72>

00000c12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>:
    @brief  Reads an 8 bit value over I2C or SPI
    @param reg the register address to read from
    @returns the data byte read from the device
*/
/**************************************************************************/
uint8_t Adafruit_BME280::read8(byte reg) {
     c12:	cf 93       	push	r28
     c14:	c8 2f       	mov	r28, r24
    uint8_t value;
    
    if (_cs == -1) {
     c16:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     c1a:	8f 3f       	cpi	r24, 0xFF	; 255
     c1c:	a9 f5       	brne	.+106    	; 0xc88 <_ZN15Adafruit_BME2805read8Eh.constprop.34+0x76>
        _wire -> beginTransmission((uint8_t)_i2caddr);
     c1e:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     c22:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     c26:	20 91 31 03 	lds	r18, 0x0331	; 0x800331 <bme+0x2>
}

void TwoWire::beginTransmission(uint8_t address)
{
  // indicate that we are transmitting
  transmitting = 1;
     c2a:	31 e0       	ldi	r19, 0x01	; 1
     c2c:	30 93 85 02 	sts	0x0285, r19	; 0x800285 <_ZN7TwoWire12transmittingE>
  // set address of targeted slave
  txAddress = address;
     c30:	20 93 84 02 	sts	0x0284, r18	; 0x800284 <_ZN7TwoWire9txAddressE>
  // reset tx buffer iterator vars
  txBufferIndex = 0;
     c34:	10 92 83 02 	sts	0x0283, r1	; 0x800283 <_ZN7TwoWire13txBufferIndexE>
  txBufferLength = 0;
     c38:	10 92 82 02 	sts	0x0282, r1	; 0x800282 <_ZN7TwoWire14txBufferLengthE>
        _wire -> write((uint8_t)reg);
     c3c:	dc 01       	movw	r26, r24
     c3e:	ed 91       	ld	r30, X+
     c40:	fc 91       	ld	r31, X
     c42:	01 90       	ld	r0, Z+
     c44:	f0 81       	ld	r31, Z
     c46:	e0 2d       	mov	r30, r0
     c48:	6c 2f       	mov	r22, r28
     c4a:	09 95       	icall
        _wire -> endTransmission();
     c4c:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     c50:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     c54:	0e 94 da 03 	call	0x7b4	; 0x7b4 <_ZN7TwoWire15endTransmissionEv>
        _wire -> requestFrom((uint8_t)_i2caddr, (byte)1);
     c58:	41 e0       	ldi	r20, 0x01	; 1
     c5a:	60 91 31 03 	lds	r22, 0x0331	; 0x800331 <bme+0x2>
     c5e:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     c62:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     c66:	0e 94 c3 05 	call	0xb86	; 0xb86 <_ZN7TwoWire11requestFromEhh>
        value = _wire -> read();
     c6a:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     c6e:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     c72:	dc 01       	movw	r26, r24
     c74:	ed 91       	ld	r30, X+
     c76:	fc 91       	ld	r31, X
     c78:	02 84       	ldd	r0, Z+10	; 0x0a
     c7a:	f3 85       	ldd	r31, Z+11	; 0x0b
     c7c:	e0 2d       	mov	r30, r0
     c7e:	09 95       	icall
     c80:	c8 2f       	mov	r28, r24
        digitalWrite(_cs, HIGH);
        if (_sck == -1)
            SPI.endTransaction(); // release the SPI bus
    }
    return value;
}
     c82:	8c 2f       	mov	r24, r28
     c84:	cf 91       	pop	r28
     c86:	08 95       	ret
        _wire -> write((uint8_t)reg);
        _wire -> endTransmission();
        _wire -> requestFrom((uint8_t)_i2caddr, (byte)1);
        value = _wire -> read();
    } else {
        if (_sck == -1)
     c88:	80 91 3d 03 	lds	r24, 0x033D	; 0x80033d <bme+0xe>
     c8c:	8f 3f       	cpi	r24, 0xFF	; 255
     c8e:	21 f4       	brne	.+8      	; 0xc98 <_ZN15Adafruit_BME2805read8Eh.constprop.34+0x86>
            SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
     c90:	82 e5       	ldi	r24, 0x52	; 82
     c92:	91 e0       	ldi	r25, 0x01	; 1
     c94:	0e 94 d3 00 	call	0x1a6	; 0x1a6 <_ZN8SPIClass16beginTransactionE11SPISettings.constprop.46>
        digitalWrite(_cs, LOW);
     c98:	60 e0       	ldi	r22, 0x00	; 0
     c9a:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     c9e:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
        spixfer(reg | 0x80); // read, bit 7 high
     ca2:	8c 2f       	mov	r24, r28
     ca4:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
        value = spixfer(0);
     ca8:	80 e0       	ldi	r24, 0x00	; 0
     caa:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
     cae:	c8 2f       	mov	r28, r24
        digitalWrite(_cs, HIGH);
     cb0:	61 e0       	ldi	r22, 0x01	; 1
     cb2:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     cb6:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
     cba:	e3 cf       	rjmp	.-58     	; 0xc82 <_ZN15Adafruit_BME2805read8Eh.constprop.34+0x70>

00000cbc <_ZN15Adafruit_BME2806read16Eh.constprop.32>:
    @brief  Reads a 16 bit value over I2C or SPI
    @param reg the register address to read from
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
uint16_t Adafruit_BME280::read16(byte reg)
     cbc:	cf 93       	push	r28
     cbe:	df 93       	push	r29
     cc0:	c8 2f       	mov	r28, r24
{
    uint16_t value;

    if (_cs == -1) {
     cc2:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     cc6:	8f 3f       	cpi	r24, 0xFF	; 255
     cc8:	09 f0       	breq	.+2      	; 0xccc <_ZN15Adafruit_BME2806read16Eh.constprop.32+0x10>
     cca:	46 c0       	rjmp	.+140    	; 0xd58 <_ZN15Adafruit_BME2806read16Eh.constprop.32+0x9c>
        _wire -> beginTransmission((uint8_t)_i2caddr);
     ccc:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     cd0:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     cd4:	20 91 31 03 	lds	r18, 0x0331	; 0x800331 <bme+0x2>
}

void TwoWire::beginTransmission(uint8_t address)
{
  // indicate that we are transmitting
  transmitting = 1;
     cd8:	31 e0       	ldi	r19, 0x01	; 1
     cda:	30 93 85 02 	sts	0x0285, r19	; 0x800285 <_ZN7TwoWire12transmittingE>
  // set address of targeted slave
  txAddress = address;
     cde:	20 93 84 02 	sts	0x0284, r18	; 0x800284 <_ZN7TwoWire9txAddressE>
  // reset tx buffer iterator vars
  txBufferIndex = 0;
     ce2:	10 92 83 02 	sts	0x0283, r1	; 0x800283 <_ZN7TwoWire13txBufferIndexE>
  txBufferLength = 0;
     ce6:	10 92 82 02 	sts	0x0282, r1	; 0x800282 <_ZN7TwoWire14txBufferLengthE>
        _wire -> write((uint8_t)reg);
     cea:	dc 01       	movw	r26, r24
     cec:	ed 91       	ld	r30, X+
     cee:	fc 91       	ld	r31, X
     cf0:	01 90       	ld	r0, Z+
     cf2:	f0 81       	ld	r31, Z
     cf4:	e0 2d       	mov	r30, r0
     cf6:	6c 2f       	mov	r22, r28
     cf8:	09 95       	icall
        _wire -> endTransmission();
     cfa:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     cfe:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     d02:	0e 94 da 03 	call	0x7b4	; 0x7b4 <_ZN7TwoWire15endTransmissionEv>
        _wire -> requestFrom((uint8_t)_i2caddr, (byte)2);
     d06:	42 e0       	ldi	r20, 0x02	; 2
     d08:	60 91 31 03 	lds	r22, 0x0331	; 0x800331 <bme+0x2>
     d0c:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     d10:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     d14:	0e 94 c3 05 	call	0xb86	; 0xb86 <_ZN7TwoWire11requestFromEhh>
        value = (_wire -> read() << 8) | _wire -> read();
     d18:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     d1c:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     d20:	dc 01       	movw	r26, r24
     d22:	ed 91       	ld	r30, X+
     d24:	fc 91       	ld	r31, X
     d26:	02 84       	ldd	r0, Z+10	; 0x0a
     d28:	f3 85       	ldd	r31, Z+11	; 0x0b
     d2a:	e0 2d       	mov	r30, r0
     d2c:	09 95       	icall
     d2e:	c8 2f       	mov	r28, r24
     d30:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     d34:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     d38:	dc 01       	movw	r26, r24
     d3a:	ed 91       	ld	r30, X+
     d3c:	fc 91       	ld	r31, X
     d3e:	02 84       	ldd	r0, Z+10	; 0x0a
     d40:	f3 85       	ldd	r31, Z+11	; 0x0b
     d42:	e0 2d       	mov	r30, r0
     d44:	09 95       	icall
     d46:	20 e0       	ldi	r18, 0x00	; 0
     d48:	3c 2f       	mov	r19, r28
     d4a:	e9 01       	movw	r28, r18
     d4c:	c8 2b       	or	r28, r24
     d4e:	d9 2b       	or	r29, r25
        if (_sck == -1)
            SPI.endTransaction(); // release the SPI bus
    }

    return value;
}
     d50:	ce 01       	movw	r24, r28
     d52:	df 91       	pop	r29
     d54:	cf 91       	pop	r28
     d56:	08 95       	ret
        _wire -> write((uint8_t)reg);
        _wire -> endTransmission();
        _wire -> requestFrom((uint8_t)_i2caddr, (byte)2);
        value = (_wire -> read() << 8) | _wire -> read();
    } else {
        if (_sck == -1)
     d58:	80 91 3d 03 	lds	r24, 0x033D	; 0x80033d <bme+0xe>
     d5c:	8f 3f       	cpi	r24, 0xFF	; 255
     d5e:	21 f4       	brne	.+8      	; 0xd68 <_ZN15Adafruit_BME2806read16Eh.constprop.32+0xac>
            SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
     d60:	82 e5       	ldi	r24, 0x52	; 82
     d62:	91 e0       	ldi	r25, 0x01	; 1
     d64:	0e 94 d3 00 	call	0x1a6	; 0x1a6 <_ZN8SPIClass16beginTransactionE11SPISettings.constprop.46>
        digitalWrite(_cs, LOW);
     d68:	60 e0       	ldi	r22, 0x00	; 0
     d6a:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     d6e:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
        spixfer(reg | 0x80); // read, bit 7 high
     d72:	8c 2f       	mov	r24, r28
     d74:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
        value = (spixfer(0) << 8) | spixfer(0);
     d78:	80 e0       	ldi	r24, 0x00	; 0
     d7a:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
     d7e:	c8 2f       	mov	r28, r24
     d80:	80 e0       	ldi	r24, 0x00	; 0
     d82:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
     d86:	dc 2f       	mov	r29, r28
     d88:	c8 2f       	mov	r28, r24
        digitalWrite(_cs, HIGH);
     d8a:	61 e0       	ldi	r22, 0x01	; 1
     d8c:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     d90:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
     d94:	dd cf       	rjmp	.-70     	; 0xd50 <_ZN15Adafruit_BME2806read16Eh.constprop.32+0x94>

00000d96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>:
    @param reg the register address to read from
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
uint16_t Adafruit_BME280::read16_LE(byte reg) {
    uint16_t temp = read16(reg);
     d96:	0e 94 5e 06 	call	0xcbc	; 0xcbc <_ZN15Adafruit_BME2806read16Eh.constprop.32>
    return (temp >> 8) | (temp << 8);
}
     d9a:	98 27       	eor	r25, r24
     d9c:	89 27       	eor	r24, r25
     d9e:	98 27       	eor	r25, r24
     da0:	08 95       	ret

00000da2 <_ZN15Adafruit_BME2806read24Eh.constprop.10>:
    @brief  Reads a 24 bit value over I2C
    @param reg the register address to read from
    @returns the 24 bit data value read from the device
*/
/**************************************************************************/
uint32_t Adafruit_BME280::read24(byte reg)
     da2:	8f 92       	push	r8
     da4:	9f 92       	push	r9
     da6:	af 92       	push	r10
     da8:	bf 92       	push	r11
     daa:	cf 92       	push	r12
     dac:	df 92       	push	r13
     dae:	ef 92       	push	r14
     db0:	ff 92       	push	r15
     db2:	f8 2e       	mov	r15, r24
{
    uint32_t value;

    if (_cs == -1) {
     db4:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     db8:	8f 3f       	cpi	r24, 0xFF	; 255
     dba:	09 f0       	breq	.+2      	; 0xdbe <_ZN15Adafruit_BME2806read24Eh.constprop.10+0x1c>
     dbc:	70 c0       	rjmp	.+224    	; 0xe9e <_ZN15Adafruit_BME2806read24Eh.constprop.10+0xfc>
        _wire -> beginTransmission((uint8_t)_i2caddr);
     dbe:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     dc2:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     dc6:	20 91 31 03 	lds	r18, 0x0331	; 0x800331 <bme+0x2>
}

void TwoWire::beginTransmission(uint8_t address)
{
  // indicate that we are transmitting
  transmitting = 1;
     dca:	31 e0       	ldi	r19, 0x01	; 1
     dcc:	30 93 85 02 	sts	0x0285, r19	; 0x800285 <_ZN7TwoWire12transmittingE>
  // set address of targeted slave
  txAddress = address;
     dd0:	20 93 84 02 	sts	0x0284, r18	; 0x800284 <_ZN7TwoWire9txAddressE>
  // reset tx buffer iterator vars
  txBufferIndex = 0;
     dd4:	10 92 83 02 	sts	0x0283, r1	; 0x800283 <_ZN7TwoWire13txBufferIndexE>
  txBufferLength = 0;
     dd8:	10 92 82 02 	sts	0x0282, r1	; 0x800282 <_ZN7TwoWire14txBufferLengthE>
        _wire -> write((uint8_t)reg);
     ddc:	dc 01       	movw	r26, r24
     dde:	ed 91       	ld	r30, X+
     de0:	fc 91       	ld	r31, X
     de2:	01 90       	ld	r0, Z+
     de4:	f0 81       	ld	r31, Z
     de6:	e0 2d       	mov	r30, r0
     de8:	6f 2d       	mov	r22, r15
     dea:	09 95       	icall
        _wire -> endTransmission();
     dec:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     df0:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     df4:	0e 94 da 03 	call	0x7b4	; 0x7b4 <_ZN7TwoWire15endTransmissionEv>
        _wire -> requestFrom((uint8_t)_i2caddr, (byte)3);
     df8:	43 e0       	ldi	r20, 0x03	; 3
     dfa:	60 91 31 03 	lds	r22, 0x0331	; 0x800331 <bme+0x2>
     dfe:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     e02:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     e06:	0e 94 c3 05 	call	0xb86	; 0xb86 <_ZN7TwoWire11requestFromEhh>

        value = _wire -> read();
     e0a:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     e0e:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     e12:	dc 01       	movw	r26, r24
     e14:	ed 91       	ld	r30, X+
     e16:	fc 91       	ld	r31, X
     e18:	02 84       	ldd	r0, Z+10	; 0x0a
     e1a:	f3 85       	ldd	r31, Z+11	; 0x0b
     e1c:	e0 2d       	mov	r30, r0
     e1e:	09 95       	icall
     e20:	4c 01       	movw	r8, r24
     e22:	99 0f       	add	r25, r25
     e24:	aa 08       	sbc	r10, r10
     e26:	bb 08       	sbc	r11, r11
        value <<= 8;
     e28:	ba 2c       	mov	r11, r10
     e2a:	a9 2c       	mov	r10, r9
     e2c:	98 2c       	mov	r9, r8
     e2e:	88 24       	eor	r8, r8
        value |= _wire -> read();
     e30:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     e34:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     e38:	dc 01       	movw	r26, r24
     e3a:	ed 91       	ld	r30, X+
     e3c:	fc 91       	ld	r31, X
     e3e:	02 84       	ldd	r0, Z+10	; 0x0a
     e40:	f3 85       	ldd	r31, Z+11	; 0x0b
     e42:	e0 2d       	mov	r30, r0
     e44:	09 95       	icall
     e46:	09 2e       	mov	r0, r25
     e48:	00 0c       	add	r0, r0
     e4a:	aa 0b       	sbc	r26, r26
     e4c:	bb 0b       	sbc	r27, r27
     e4e:	88 2a       	or	r8, r24
     e50:	99 2a       	or	r9, r25
     e52:	aa 2a       	or	r10, r26
     e54:	bb 2a       	or	r11, r27
        value <<= 8;
     e56:	ba 2c       	mov	r11, r10
     e58:	a9 2c       	mov	r10, r9
     e5a:	98 2c       	mov	r9, r8
     e5c:	88 24       	eor	r8, r8
        value |= _wire -> read();
     e5e:	80 91 2f 03 	lds	r24, 0x032F	; 0x80032f <bme>
     e62:	90 91 30 03 	lds	r25, 0x0330	; 0x800330 <bme+0x1>
     e66:	dc 01       	movw	r26, r24
     e68:	ed 91       	ld	r30, X+
     e6a:	fc 91       	ld	r31, X
     e6c:	02 84       	ldd	r0, Z+10	; 0x0a
     e6e:	f3 85       	ldd	r31, Z+11	; 0x0b
     e70:	e0 2d       	mov	r30, r0
     e72:	09 95       	icall
     e74:	09 2e       	mov	r0, r25
     e76:	00 0c       	add	r0, r0
     e78:	aa 0b       	sbc	r26, r26
     e7a:	bb 0b       	sbc	r27, r27
     e7c:	6c 01       	movw	r12, r24
     e7e:	7d 01       	movw	r14, r26
     e80:	c8 28       	or	r12, r8
     e82:	d9 28       	or	r13, r9
     e84:	ea 28       	or	r14, r10
     e86:	fb 28       	or	r15, r11
        if (_sck == -1)
            SPI.endTransaction(); // release the SPI bus
    }

    return value;
}
     e88:	c7 01       	movw	r24, r14
     e8a:	b6 01       	movw	r22, r12
     e8c:	ff 90       	pop	r15
     e8e:	ef 90       	pop	r14
     e90:	df 90       	pop	r13
     e92:	cf 90       	pop	r12
     e94:	bf 90       	pop	r11
     e96:	af 90       	pop	r10
     e98:	9f 90       	pop	r9
     e9a:	8f 90       	pop	r8
     e9c:	08 95       	ret
        value <<= 8;
        value |= _wire -> read();
        value <<= 8;
        value |= _wire -> read();
    } else {
        if (_sck == -1)
     e9e:	80 91 3d 03 	lds	r24, 0x033D	; 0x80033d <bme+0xe>
     ea2:	8f 3f       	cpi	r24, 0xFF	; 255
     ea4:	21 f4       	brne	.+8      	; 0xeae <_ZN15Adafruit_BME2806read24Eh.constprop.10+0x10c>
            SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
     ea6:	82 e5       	ldi	r24, 0x52	; 82
     ea8:	91 e0       	ldi	r25, 0x01	; 1
     eaa:	0e 94 d3 00 	call	0x1a6	; 0x1a6 <_ZN8SPIClass16beginTransactionE11SPISettings.constprop.46>
        digitalWrite(_cs, LOW);
     eae:	60 e0       	ldi	r22, 0x00	; 0
     eb0:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     eb4:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
        spixfer(reg | 0x80); // read, bit 7 high
     eb8:	8f 2d       	mov	r24, r15
     eba:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>

        value = spixfer(0);
     ebe:	80 e0       	ldi	r24, 0x00	; 0
     ec0:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
     ec4:	90 e0       	ldi	r25, 0x00	; 0
     ec6:	b0 e0       	ldi	r27, 0x00	; 0
     ec8:	a0 e0       	ldi	r26, 0x00	; 0
        value <<= 8;
     eca:	cc 24       	eor	r12, r12
     ecc:	d8 2e       	mov	r13, r24
     ece:	e9 2e       	mov	r14, r25
     ed0:	fa 2e       	mov	r15, r26
        value |= spixfer(0);
     ed2:	80 e0       	ldi	r24, 0x00	; 0
     ed4:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
     ed8:	c8 2a       	or	r12, r24
        value <<= 8;
     eda:	fe 2c       	mov	r15, r14
     edc:	ed 2c       	mov	r14, r13
     ede:	dc 2c       	mov	r13, r12
     ee0:	cc 24       	eor	r12, r12
        value |= spixfer(0);
     ee2:	80 e0       	ldi	r24, 0x00	; 0
     ee4:	0e 94 3c 02 	call	0x478	; 0x478 <_ZN15Adafruit_BME2807spixferEh.constprop.47>
     ee8:	c8 2a       	or	r12, r24

        digitalWrite(_cs, HIGH);
     eea:	61 e0       	ldi	r22, 0x01	; 1
     eec:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
     ef0:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
     ef4:	c9 cf       	rjmp	.-110    	; 0xe88 <_ZN15Adafruit_BME2806read24Eh.constprop.10+0xe6>

00000ef6 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9>:
/*!
    @brief  Returns the temperature from the sensor
    @returns the temperature read from the device
*/
/**************************************************************************/
float Adafruit_BME280::readTemperature(void)
     ef6:	8f 92       	push	r8
     ef8:	9f 92       	push	r9
     efa:	af 92       	push	r10
     efc:	bf 92       	push	r11
     efe:	cf 92       	push	r12
     f00:	df 92       	push	r13
     f02:	ef 92       	push	r14
     f04:	ff 92       	push	r15
     f06:	0f 93       	push	r16
     f08:	1f 93       	push	r17
{
    int32_t var1, var2;

    int32_t adc_T = read24(BME280_REGISTER_TEMPDATA);
     f0a:	8a ef       	ldi	r24, 0xFA	; 250
     f0c:	0e 94 d1 06 	call	0xda2	; 0xda2 <_ZN15Adafruit_BME2806read24Eh.constprop.10>
    if (adc_T == 0x800000) // value in case temp measurement was disabled
     f10:	61 15       	cp	r22, r1
     f12:	71 05       	cpc	r23, r1
     f14:	20 e8       	ldi	r18, 0x80	; 128
     f16:	82 07       	cpc	r24, r18
     f18:	91 05       	cpc	r25, r1
     f1a:	09 f4       	brne	.+2      	; 0xf1e <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9+0x28>
     f1c:	7d c0       	rjmp	.+250    	; 0x1018 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9+0x122>
        return NAN;
    adc_T >>= 4;

    var1 = ((((adc_T>>3) - ((int32_t)_bme280_calib.dig_T1 <<1))) *
     f1e:	00 91 3e 03 	lds	r16, 0x033E	; 0x80033e <bme+0xf>
     f22:	10 91 3f 03 	lds	r17, 0x033F	; 0x80033f <bme+0x10>
     f26:	30 e0       	ldi	r19, 0x00	; 0
     f28:	20 e0       	ldi	r18, 0x00	; 0
            ((int32_t)_bme280_calib.dig_T2)) >> 11;
             
    var2 = (((((adc_T>>4) - ((int32_t)_bme280_calib.dig_T1)) *
     f2a:	c7 2e       	mov	r12, r23
     f2c:	d8 2e       	mov	r13, r24
     f2e:	e9 2e       	mov	r14, r25
     f30:	ff 24       	eor	r15, r15
     f32:	e7 fc       	sbrc	r14, 7
     f34:	fa 94       	dec	r15
     f36:	c0 1a       	sub	r12, r16
     f38:	d1 0a       	sbc	r13, r17
     f3a:	e2 0a       	sbc	r14, r18
     f3c:	f3 0a       	sbc	r15, r19
    int32_t adc_T = read24(BME280_REGISTER_TEMPDATA);
    if (adc_T == 0x800000) // value in case temp measurement was disabled
        return NAN;
    adc_T >>= 4;

    var1 = ((((adc_T>>3) - ((int32_t)_bme280_calib.dig_T1 <<1))) *
     f3e:	57 e0       	ldi	r21, 0x07	; 7
     f40:	95 95       	asr	r25
     f42:	87 95       	ror	r24
     f44:	77 95       	ror	r23
     f46:	67 95       	ror	r22
     f48:	5a 95       	dec	r21
     f4a:	d1 f7       	brne	.-12     	; 0xf40 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9+0x4a>
     f4c:	00 0f       	add	r16, r16
     f4e:	11 1f       	adc	r17, r17
     f50:	22 1f       	adc	r18, r18
     f52:	33 1f       	adc	r19, r19
     f54:	4b 01       	movw	r8, r22
     f56:	5c 01       	movw	r10, r24
     f58:	80 1a       	sub	r8, r16
     f5a:	91 0a       	sbc	r9, r17
     f5c:	a2 0a       	sbc	r10, r18
     f5e:	b3 0a       	sbc	r11, r19
     f60:	a5 01       	movw	r20, r10
     f62:	94 01       	movw	r18, r8
            ((int32_t)_bme280_calib.dig_T2)) >> 11;
     f64:	a0 91 40 03 	lds	r26, 0x0340	; 0x800340 <bme+0x11>
     f68:	b0 91 41 03 	lds	r27, 0x0341	; 0x800341 <bme+0x12>
    int32_t adc_T = read24(BME280_REGISTER_TEMPDATA);
    if (adc_T == 0x800000) // value in case temp measurement was disabled
        return NAN;
    adc_T >>= 4;

    var1 = ((((adc_T>>3) - ((int32_t)_bme280_calib.dig_T1 <<1))) *
     f6c:	0e 94 cc 13 	call	0x2798	; 0x2798 <__mulshisi3>
     f70:	4b 01       	movw	r8, r22
     f72:	5c 01       	movw	r10, r24
     f74:	fb e0       	ldi	r31, 0x0B	; 11
     f76:	b5 94       	asr	r11
     f78:	a7 94       	ror	r10
     f7a:	97 94       	ror	r9
     f7c:	87 94       	ror	r8
     f7e:	fa 95       	dec	r31
     f80:	d1 f7       	brne	.-12     	; 0xf76 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9+0x80>
            ((int32_t)_bme280_calib.dig_T2)) >> 11;
             
    var2 = (((((adc_T>>4) - ((int32_t)_bme280_calib.dig_T1)) *
     f82:	a7 01       	movw	r20, r14
     f84:	96 01       	movw	r18, r12
     f86:	c7 01       	movw	r24, r14
     f88:	b6 01       	movw	r22, r12
     f8a:	0e 94 8f 13 	call	0x271e	; 0x271e <__mulsi3>
              ((adc_T>>4) - ((int32_t)_bme280_calib.dig_T1))) >> 12) *
     f8e:	9b 01       	movw	r18, r22
     f90:	ac 01       	movw	r20, r24
     f92:	ac e0       	ldi	r26, 0x0C	; 12
     f94:	55 95       	asr	r21
     f96:	47 95       	ror	r20
     f98:	37 95       	ror	r19
     f9a:	27 95       	ror	r18
     f9c:	aa 95       	dec	r26
     f9e:	d1 f7       	brne	.-12     	; 0xf94 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9+0x9e>
            ((int32_t)_bme280_calib.dig_T3)) >> 14;
     fa0:	a0 91 42 03 	lds	r26, 0x0342	; 0x800342 <bme+0x13>
     fa4:	b0 91 43 03 	lds	r27, 0x0343	; 0x800343 <bme+0x14>

    var1 = ((((adc_T>>3) - ((int32_t)_bme280_calib.dig_T1 <<1))) *
            ((int32_t)_bme280_calib.dig_T2)) >> 11;
             
    var2 = (((((adc_T>>4) - ((int32_t)_bme280_calib.dig_T1)) *
              ((adc_T>>4) - ((int32_t)_bme280_calib.dig_T1))) >> 12) *
     fa8:	0e 94 cc 13 	call	0x2798	; 0x2798 <__mulshisi3>
    adc_T >>= 4;

    var1 = ((((adc_T>>3) - ((int32_t)_bme280_calib.dig_T1 <<1))) *
            ((int32_t)_bme280_calib.dig_T2)) >> 11;
             
    var2 = (((((adc_T>>4) - ((int32_t)_bme280_calib.dig_T1)) *
     fac:	9b 01       	movw	r18, r22
     fae:	ac 01       	movw	r20, r24
     fb0:	be e0       	ldi	r27, 0x0E	; 14
     fb2:	55 95       	asr	r21
     fb4:	47 95       	ror	r20
     fb6:	37 95       	ror	r19
     fb8:	27 95       	ror	r18
     fba:	ba 95       	dec	r27
     fbc:	d1 f7       	brne	.-12     	; 0xfb2 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9+0xbc>
              ((adc_T>>4) - ((int32_t)_bme280_calib.dig_T1))) >> 12) *
            ((int32_t)_bme280_calib.dig_T3)) >> 14;

    t_fine = var1 + var2;
     fbe:	28 0d       	add	r18, r8
     fc0:	39 1d       	adc	r19, r9
     fc2:	4a 1d       	adc	r20, r10
     fc4:	5b 1d       	adc	r21, r11
     fc6:	20 93 36 03 	sts	0x0336, r18	; 0x800336 <bme+0x7>
     fca:	30 93 37 03 	sts	0x0337, r19	; 0x800337 <bme+0x8>
     fce:	40 93 38 03 	sts	0x0338, r20	; 0x800338 <bme+0x9>
     fd2:	50 93 39 03 	sts	0x0339, r21	; 0x800339 <bme+0xa>

    float T = (t_fine * 5 + 128) >> 8;
     fd6:	a5 e0       	ldi	r26, 0x05	; 5
     fd8:	b0 e0       	ldi	r27, 0x00	; 0
     fda:	0e 94 c1 13 	call	0x2782	; 0x2782 <__muluhisi3>
     fde:	60 58       	subi	r22, 0x80	; 128
     fe0:	7f 4f       	sbci	r23, 0xFF	; 255
     fe2:	8f 4f       	sbci	r24, 0xFF	; 255
     fe4:	9f 4f       	sbci	r25, 0xFF	; 255
     fe6:	67 2f       	mov	r22, r23
     fe8:	78 2f       	mov	r23, r24
     fea:	89 2f       	mov	r24, r25
     fec:	99 27       	eor	r25, r25
     fee:	87 fd       	sbrc	r24, 7
     ff0:	9a 95       	dec	r25
     ff2:	0e 94 95 10 	call	0x212a	; 0x212a <__floatsisf>
    return T/100;
     ff6:	20 e0       	ldi	r18, 0x00	; 0
     ff8:	30 e0       	ldi	r19, 0x00	; 0
     ffa:	48 ec       	ldi	r20, 0xC8	; 200
     ffc:	52 e4       	ldi	r21, 0x42	; 66
     ffe:	0e 94 ec 0f 	call	0x1fd8	; 0x1fd8 <__divsf3>
}
    1002:	1f 91       	pop	r17
    1004:	0f 91       	pop	r16
    1006:	ff 90       	pop	r15
    1008:	ef 90       	pop	r14
    100a:	df 90       	pop	r13
    100c:	cf 90       	pop	r12
    100e:	bf 90       	pop	r11
    1010:	af 90       	pop	r10
    1012:	9f 90       	pop	r9
    1014:	8f 90       	pop	r8
    1016:	08 95       	ret
{
    int32_t var1, var2;

    int32_t adc_T = read24(BME280_REGISTER_TEMPDATA);
    if (adc_T == 0x800000) // value in case temp measurement was disabled
        return NAN;
    1018:	60 e0       	ldi	r22, 0x00	; 0
    101a:	70 e0       	ldi	r23, 0x00	; 0
    101c:	80 ec       	ldi	r24, 0xC0	; 192
    101e:	9f e7       	ldi	r25, 0x7F	; 127
    1020:	f0 cf       	rjmp	.-32     	; 0x1002 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9+0x10c>

00001022 <_ZN15Adafruit_BME28012readPressureEv.constprop.6>:
/*!
    @brief  Returns the pressure from the sensor
    @returns the pressure value (in Pascal) read from the device
*/
/**************************************************************************/
float Adafruit_BME280::readPressure(void) {
    1022:	2f 92       	push	r2
    1024:	3f 92       	push	r3
    1026:	4f 92       	push	r4
    1028:	5f 92       	push	r5
    102a:	6f 92       	push	r6
    102c:	7f 92       	push	r7
    102e:	8f 92       	push	r8
    1030:	9f 92       	push	r9
    1032:	af 92       	push	r10
    1034:	bf 92       	push	r11
    1036:	cf 92       	push	r12
    1038:	df 92       	push	r13
    103a:	ef 92       	push	r14
    103c:	ff 92       	push	r15
    103e:	0f 93       	push	r16
    1040:	1f 93       	push	r17
    1042:	cf 93       	push	r28
    1044:	df 93       	push	r29
    1046:	cd b7       	in	r28, 0x3d	; 61
    1048:	de b7       	in	r29, 0x3e	; 62
    104a:	68 97       	sbiw	r28, 0x18	; 24
    104c:	0f b6       	in	r0, 0x3f	; 63
    104e:	f8 94       	cli
    1050:	de bf       	out	0x3e, r29	; 62
    1052:	0f be       	out	0x3f, r0	; 63
    1054:	cd bf       	out	0x3d, r28	; 61
    int64_t var1, var2, p;

    readTemperature(); // must be done first to get t_fine
    1056:	0e 94 7b 07 	call	0xef6	; 0xef6 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9>

    int32_t adc_P = read24(BME280_REGISTER_PRESSUREDATA);
    105a:	87 ef       	ldi	r24, 0xF7	; 247
    105c:	0e 94 d1 06 	call	0xda2	; 0xda2 <_ZN15Adafruit_BME2806read24Eh.constprop.10>
    1060:	6b 87       	std	Y+11, r22	; 0x0b
    1062:	7c 87       	std	Y+12, r23	; 0x0c
    1064:	8d 87       	std	Y+13, r24	; 0x0d
    1066:	9e 87       	std	Y+14, r25	; 0x0e
    if (adc_P == 0x800000) // value in case pressure measurement was disabled
    1068:	61 15       	cp	r22, r1
    106a:	71 05       	cpc	r23, r1
    106c:	80 48       	sbci	r24, 0x80	; 128
    106e:	91 05       	cpc	r25, r1
    1070:	09 f4       	brne	.+2      	; 0x1074 <_ZN15Adafruit_BME28012readPressureEv.constprop.6+0x52>
    1072:	bd c1       	rjmp	.+890    	; 0x13ee <_ZN15Adafruit_BME28012readPressureEv.constprop.6+0x3cc>
        return NAN;
    adc_P >>= 4;

    var1 = ((int64_t)t_fine) - 128000;
    1074:	80 91 36 03 	lds	r24, 0x0336	; 0x800336 <bme+0x7>
    1078:	90 91 37 03 	lds	r25, 0x0337	; 0x800337 <bme+0x8>
    107c:	a0 91 38 03 	lds	r26, 0x0338	; 0x800338 <bme+0x9>
    1080:	b0 91 39 03 	lds	r27, 0x0339	; 0x800339 <bme+0xa>
    1084:	6c 01       	movw	r12, r24
    1086:	7d 01       	movw	r14, r26
    1088:	ff 0c       	add	r15, r15
    108a:	cc 08       	sbc	r12, r12
    108c:	dc 2c       	mov	r13, r12
    108e:	76 01       	movw	r14, r12
    1090:	9c 01       	movw	r18, r24
    1092:	ad 01       	movw	r20, r26
    1094:	6c 2d       	mov	r22, r12
    1096:	7c 2d       	mov	r23, r12
    1098:	8c 2d       	mov	r24, r12
    109a:	9c 2d       	mov	r25, r12
    109c:	34 5f       	subi	r19, 0xF4	; 244
    109e:	41 40       	sbci	r20, 0x01	; 1
    10a0:	51 09       	sbc	r21, r1
    10a2:	61 09       	sbc	r22, r1
    10a4:	71 09       	sbc	r23, r1
    10a6:	81 09       	sbc	r24, r1
    10a8:	91 09       	sbc	r25, r1
    10aa:	29 83       	std	Y+1, r18	; 0x01
    10ac:	3a 83       	std	Y+2, r19	; 0x02
    10ae:	4b 83       	std	Y+3, r20	; 0x03
    10b0:	5c 83       	std	Y+4, r21	; 0x04
    10b2:	6d 83       	std	Y+5, r22	; 0x05
    10b4:	7e 83       	std	Y+6, r23	; 0x06
    10b6:	88 8f       	std	Y+24, r24	; 0x18
    10b8:	9f 8b       	std	Y+23, r25	; 0x17
    var2 = var1 * var1 * (int64_t)_bme280_calib.dig_P6;
    10ba:	59 01       	movw	r10, r18
    10bc:	6a 01       	movw	r12, r20
    10be:	7b 01       	movw	r14, r22
    10c0:	8c 01       	movw	r16, r24
    10c2:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    10c6:	2f 83       	std	Y+7, r18	; 0x07
    10c8:	38 87       	std	Y+8, r19	; 0x08
    10ca:	49 87       	std	Y+9, r20	; 0x09
    10cc:	5a 87       	std	Y+10, r21	; 0x0a
    10ce:	6b 8b       	std	Y+19, r22	; 0x13
    10d0:	7c 8b       	std	Y+20, r23	; 0x14
    10d2:	8d 8b       	std	Y+21, r24	; 0x15
    10d4:	9e 8b       	std	Y+22, r25	; 0x16
    var2 = var2 + ((var1*(int64_t)_bme280_calib.dig_P5)<<17);
    var2 = var2 + (((int64_t)_bme280_calib.dig_P4)<<35);
    var1 = ((var1 * var1 * (int64_t)_bme280_calib.dig_P3)>>8) +
           ((var1 * (int64_t)_bme280_calib.dig_P2)<<12);
    10d6:	30 91 47 03 	lds	r19, 0x0347	; 0x800347 <bme+0x18>
    10da:	20 91 46 03 	lds	r18, 0x0346	; 0x800346 <bme+0x17>
    10de:	93 2f       	mov	r25, r19
    10e0:	99 0f       	add	r25, r25
    10e2:	99 0b       	sbc	r25, r25
    10e4:	49 2f       	mov	r20, r25
    10e6:	59 2f       	mov	r21, r25
    10e8:	69 2f       	mov	r22, r25
    10ea:	79 2f       	mov	r23, r25
    10ec:	89 2f       	mov	r24, r25
    10ee:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    10f2:	0c e0       	ldi	r16, 0x0C	; 12
    10f4:	0e 94 03 15 	call	0x2a06	; 0x2a06 <__ashldi3>
    10f8:	19 01       	movw	r2, r18
    10fa:	94 2e       	mov	r9, r20
    10fc:	85 2e       	mov	r8, r21
    10fe:	76 2e       	mov	r7, r22
    1100:	67 2e       	mov	r6, r23
    1102:	58 2e       	mov	r5, r24
    1104:	49 2e       	mov	r4, r25

    var1 = ((int64_t)t_fine) - 128000;
    var2 = var1 * var1 * (int64_t)_bme280_calib.dig_P6;
    var2 = var2 + ((var1*(int64_t)_bme280_calib.dig_P5)<<17);
    var2 = var2 + (((int64_t)_bme280_calib.dig_P4)<<35);
    var1 = ((var1 * var1 * (int64_t)_bme280_calib.dig_P3)>>8) +
    1106:	30 91 49 03 	lds	r19, 0x0349	; 0x800349 <bme+0x1a>
    110a:	20 91 48 03 	lds	r18, 0x0348	; 0x800348 <bme+0x19>
    110e:	93 2f       	mov	r25, r19
    1110:	99 0f       	add	r25, r25
    1112:	99 0b       	sbc	r25, r25
    1114:	af 80       	ldd	r10, Y+7	; 0x07
    1116:	b8 84       	ldd	r11, Y+8	; 0x08
    1118:	c9 84       	ldd	r12, Y+9	; 0x09
    111a:	da 84       	ldd	r13, Y+10	; 0x0a
    111c:	eb 88       	ldd	r14, Y+19	; 0x13
    111e:	fc 88       	ldd	r15, Y+20	; 0x14
    1120:	0d 89       	ldd	r16, Y+21	; 0x15
    1122:	1e 89       	ldd	r17, Y+22	; 0x16
    1124:	49 2f       	mov	r20, r25
    1126:	59 2f       	mov	r21, r25
    1128:	69 2f       	mov	r22, r25
    112a:	79 2f       	mov	r23, r25
    112c:	89 2f       	mov	r24, r25
    112e:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    1132:	08 e0       	ldi	r16, 0x08	; 8
    1134:	0e 94 1c 15 	call	0x2a38	; 0x2a38 <__ashrdi3>
    1138:	51 01       	movw	r10, r2
    113a:	c9 2c       	mov	r12, r9
    113c:	d8 2c       	mov	r13, r8
    113e:	e7 2c       	mov	r14, r7
    1140:	f6 2c       	mov	r15, r6
    1142:	05 2d       	mov	r16, r5
    1144:	14 2d       	mov	r17, r4
    1146:	0e 94 39 15 	call	0x2a72	; 0x2a72 <__adddi3>
           ((var1 * (int64_t)_bme280_calib.dig_P2)<<12);
    var1 = (((((int64_t)1)<<47)+var1))*((int64_t)_bme280_calib.dig_P1)>>33;
    114a:	70 58       	subi	r23, 0x80	; 128
    114c:	8f 4f       	sbci	r24, 0xFF	; 255
    114e:	9f 4f       	sbci	r25, 0xFF	; 255
    1150:	20 90 44 03 	lds	r2, 0x0344	; 0x800344 <bme+0x15>
    1154:	30 90 45 03 	lds	r3, 0x0345	; 0x800345 <bme+0x16>
    1158:	51 01       	movw	r10, r2
    115a:	c1 2c       	mov	r12, r1
    115c:	d1 2c       	mov	r13, r1
    115e:	e1 2c       	mov	r14, r1
    1160:	f1 2c       	mov	r15, r1
    1162:	00 e0       	ldi	r16, 0x00	; 0
    1164:	10 e0       	ldi	r17, 0x00	; 0
    1166:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    116a:	01 e2       	ldi	r16, 0x21	; 33
    116c:	0e 94 1c 15 	call	0x2a38	; 0x2a38 <__ashrdi3>
    1170:	32 2e       	mov	r3, r18
    1172:	23 2e       	mov	r2, r19
    1174:	4f 87       	std	Y+15, r20	; 0x0f
    1176:	58 8b       	std	Y+16, r21	; 0x10
    1178:	69 8b       	std	Y+17, r22	; 0x11
    117a:	47 2e       	mov	r4, r23
    117c:	58 2e       	mov	r5, r24
    117e:	9a 8b       	std	Y+18, r25	; 0x12

    if (var1 == 0) {
    1180:	a0 e0       	ldi	r26, 0x00	; 0
    1182:	0e 94 4b 15 	call	0x2a96	; 0x2a96 <__cmpdi2_s8>
    1186:	09 f4       	brne	.+2      	; 0x118a <_ZN15Adafruit_BME28012readPressureEv.constprop.6+0x168>
    1188:	37 c1       	rjmp	.+622    	; 0x13f8 <_ZN15Adafruit_BME28012readPressureEv.constprop.6+0x3d6>
    if (adc_P == 0x800000) // value in case pressure measurement was disabled
        return NAN;
    adc_P >>= 4;

    var1 = ((int64_t)t_fine) - 128000;
    var2 = var1 * var1 * (int64_t)_bme280_calib.dig_P6;
    118a:	30 91 4f 03 	lds	r19, 0x034F	; 0x80034f <bme+0x20>
    118e:	20 91 4e 03 	lds	r18, 0x034E	; 0x80034e <bme+0x1f>
    1192:	93 2f       	mov	r25, r19
    1194:	99 0f       	add	r25, r25
    1196:	99 0b       	sbc	r25, r25
    1198:	af 80       	ldd	r10, Y+7	; 0x07
    119a:	b8 84       	ldd	r11, Y+8	; 0x08
    119c:	c9 84       	ldd	r12, Y+9	; 0x09
    119e:	da 84       	ldd	r13, Y+10	; 0x0a
    11a0:	eb 88       	ldd	r14, Y+19	; 0x13
    11a2:	fc 88       	ldd	r15, Y+20	; 0x14
    11a4:	0d 89       	ldd	r16, Y+21	; 0x15
    11a6:	1e 89       	ldd	r17, Y+22	; 0x16
    11a8:	49 2f       	mov	r20, r25
    11aa:	59 2f       	mov	r21, r25
    11ac:	69 2f       	mov	r22, r25
    11ae:	79 2f       	mov	r23, r25
    11b0:	89 2f       	mov	r24, r25
    11b2:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    11b6:	2f 83       	std	Y+7, r18	; 0x07
    11b8:	38 87       	std	Y+8, r19	; 0x08
    11ba:	3a 01       	movw	r6, r20
    11bc:	4b 01       	movw	r8, r22
    11be:	89 87       	std	Y+9, r24	; 0x09
    11c0:	9a 87       	std	Y+10, r25	; 0x0a
    var2 = var2 + ((var1*(int64_t)_bme280_calib.dig_P5)<<17);
    11c2:	30 91 4d 03 	lds	r19, 0x034D	; 0x80034d <bme+0x1e>
    11c6:	20 91 4c 03 	lds	r18, 0x034C	; 0x80034c <bme+0x1d>
    11ca:	93 2f       	mov	r25, r19
    11cc:	99 0f       	add	r25, r25
    11ce:	99 0b       	sbc	r25, r25
    11d0:	a9 80       	ldd	r10, Y+1	; 0x01
    11d2:	ba 80       	ldd	r11, Y+2	; 0x02
    11d4:	cb 80       	ldd	r12, Y+3	; 0x03
    11d6:	dc 80       	ldd	r13, Y+4	; 0x04
    11d8:	ed 80       	ldd	r14, Y+5	; 0x05
    11da:	fe 80       	ldd	r15, Y+6	; 0x06
    11dc:	08 8d       	ldd	r16, Y+24	; 0x18
    11de:	1f 89       	ldd	r17, Y+23	; 0x17
    11e0:	49 2f       	mov	r20, r25
    11e2:	59 2f       	mov	r21, r25
    11e4:	69 2f       	mov	r22, r25
    11e6:	79 2f       	mov	r23, r25
    11e8:	89 2f       	mov	r24, r25
    11ea:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    11ee:	01 e1       	ldi	r16, 0x11	; 17
    11f0:	0e 94 03 15 	call	0x2a06	; 0x2a06 <__ashldi3>
    11f4:	af 80       	ldd	r10, Y+7	; 0x07
    11f6:	b8 84       	ldd	r11, Y+8	; 0x08
    11f8:	63 01       	movw	r12, r6
    11fa:	74 01       	movw	r14, r8
    11fc:	09 85       	ldd	r16, Y+9	; 0x09
    11fe:	1a 85       	ldd	r17, Y+10	; 0x0a
    1200:	0e 94 39 15 	call	0x2a72	; 0x2a72 <__adddi3>
    1204:	59 01       	movw	r10, r18
    1206:	6a 01       	movw	r12, r20
    1208:	7b 01       	movw	r14, r22
    120a:	89 83       	std	Y+1, r24	; 0x01
    120c:	19 2f       	mov	r17, r25
    readTemperature(); // must be done first to get t_fine

    int32_t adc_P = read24(BME280_REGISTER_PRESSUREDATA);
    if (adc_P == 0x800000) // value in case pressure measurement was disabled
        return NAN;
    adc_P >>= 4;
    120e:	4b 85       	ldd	r20, Y+11	; 0x0b
    1210:	5c 85       	ldd	r21, Y+12	; 0x0c
    1212:	6d 85       	ldd	r22, Y+13	; 0x0d
    1214:	7e 85       	ldd	r23, Y+14	; 0x0e
    1216:	84 e0       	ldi	r24, 0x04	; 4
    1218:	75 95       	asr	r23
    121a:	67 95       	ror	r22
    121c:	57 95       	ror	r21
    121e:	47 95       	ror	r20
    1220:	8a 95       	dec	r24
    1222:	d1 f7       	brne	.-12     	; 0x1218 <_ZN15Adafruit_BME28012readPressureEv.constprop.6+0x1f6>
    var1 = (((((int64_t)1)<<47)+var1))*((int64_t)_bme280_calib.dig_P1)>>33;

    if (var1 == 0) {
        return 0; // avoid exception caused by division by zero
    }
    p = 1048576 - adc_P;
    1224:	80 e0       	ldi	r24, 0x00	; 0
    1226:	90 e0       	ldi	r25, 0x00	; 0
    1228:	a0 e1       	ldi	r26, 0x10	; 16
    122a:	b0 e0       	ldi	r27, 0x00	; 0
    122c:	84 1b       	sub	r24, r20
    122e:	95 0b       	sbc	r25, r21
    1230:	a6 0b       	sbc	r26, r22
    1232:	b7 0b       	sbc	r27, r23
    1234:	3c 01       	movw	r6, r24
    1236:	4d 01       	movw	r8, r26
    1238:	99 0c       	add	r9, r9
    123a:	66 08       	sbc	r6, r6
    123c:	76 2c       	mov	r7, r6
    123e:	43 01       	movw	r8, r6
    p = (((p<<31) - var2)*3125) / var1;
    1240:	9c 01       	movw	r18, r24
    1242:	ad 01       	movw	r20, r26
    1244:	66 2d       	mov	r22, r6
    1246:	76 2d       	mov	r23, r6
    1248:	86 2d       	mov	r24, r6
    124a:	96 2d       	mov	r25, r6
    124c:	0f e1       	ldi	r16, 0x1F	; 31
    124e:	0e 94 03 15 	call	0x2a06	; 0x2a06 <__ashldi3>
    1252:	49 01       	movw	r8, r18
    1254:	4b 83       	std	Y+3, r20	; 0x03
    1256:	5a 83       	std	Y+2, r21	; 0x02
    1258:	b6 2f       	mov	r27, r22
    125a:	a7 2f       	mov	r26, r23
    125c:	f8 2f       	mov	r31, r24
    125e:	e9 2f       	mov	r30, r25
    adc_P >>= 4;

    var1 = ((int64_t)t_fine) - 128000;
    var2 = var1 * var1 * (int64_t)_bme280_calib.dig_P6;
    var2 = var2 + ((var1*(int64_t)_bme280_calib.dig_P5)<<17);
    var2 = var2 + (((int64_t)_bme280_calib.dig_P4)<<35);
    1260:	30 91 4b 03 	lds	r19, 0x034B	; 0x80034b <bme+0x1c>
    1264:	20 91 4a 03 	lds	r18, 0x034A	; 0x80034a <bme+0x1b>
    1268:	93 2f       	mov	r25, r19
    126a:	99 0f       	add	r25, r25
    126c:	99 0b       	sbc	r25, r25
    126e:	49 2f       	mov	r20, r25
    1270:	59 2f       	mov	r21, r25
    1272:	69 2f       	mov	r22, r25
    1274:	79 2f       	mov	r23, r25
    1276:	89 2f       	mov	r24, r25
    1278:	03 e2       	ldi	r16, 0x23	; 35
    127a:	0e 94 03 15 	call	0x2a06	; 0x2a06 <__ashldi3>
    127e:	09 81       	ldd	r16, Y+1	; 0x01
    1280:	0e 94 39 15 	call	0x2a72	; 0x2a72 <__adddi3>
    1284:	59 01       	movw	r10, r18
    1286:	6a 01       	movw	r12, r20
    1288:	7b 01       	movw	r14, r22
    128a:	8c 01       	movw	r16, r24

    if (var1 == 0) {
        return 0; // avoid exception caused by division by zero
    }
    p = 1048576 - adc_P;
    p = (((p<<31) - var2)*3125) / var1;
    128c:	94 01       	movw	r18, r8
    128e:	4b 81       	ldd	r20, Y+3	; 0x03
    1290:	5a 81       	ldd	r21, Y+2	; 0x02
    1292:	6b 2f       	mov	r22, r27
    1294:	7a 2f       	mov	r23, r26
    1296:	8f 2f       	mov	r24, r31
    1298:	9e 2f       	mov	r25, r30
    129a:	0e 94 42 15 	call	0x2a84	; 0x2a84 <__subdi3>
    129e:	e5 e3       	ldi	r30, 0x35	; 53
    12a0:	ae 2e       	mov	r10, r30
    12a2:	fc e0       	ldi	r31, 0x0C	; 12
    12a4:	bf 2e       	mov	r11, r31
    12a6:	c1 2c       	mov	r12, r1
    12a8:	d1 2c       	mov	r13, r1
    12aa:	e1 2c       	mov	r14, r1
    12ac:	f1 2c       	mov	r15, r1
    12ae:	00 e0       	ldi	r16, 0x00	; 0
    12b0:	10 e0       	ldi	r17, 0x00	; 0
    12b2:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    12b6:	a3 2c       	mov	r10, r3
    12b8:	b2 2c       	mov	r11, r2
    12ba:	cf 84       	ldd	r12, Y+15	; 0x0f
    12bc:	d8 88       	ldd	r13, Y+16	; 0x10
    12be:	e9 88       	ldd	r14, Y+17	; 0x11
    12c0:	f4 2c       	mov	r15, r4
    12c2:	05 2d       	mov	r16, r5
    12c4:	1a 89       	ldd	r17, Y+18	; 0x12
    12c6:	0e 94 2e 14 	call	0x285c	; 0x285c <__divdi3>
    12ca:	28 87       	std	Y+8, r18	; 0x08
    12cc:	3f 83       	std	Y+7, r19	; 0x07
    12ce:	49 83       	std	Y+1, r20	; 0x01
    12d0:	5a 83       	std	Y+2, r21	; 0x02
    12d2:	6b 83       	std	Y+3, r22	; 0x03
    12d4:	7c 83       	std	Y+4, r23	; 0x04
    12d6:	8d 83       	std	Y+5, r24	; 0x05
    12d8:	9e 83       	std	Y+6, r25	; 0x06
    var1 = (((int64_t)_bme280_calib.dig_P9) * (p>>13) * (p>>13)) >> 25;
    12da:	0d e0       	ldi	r16, 0x0D	; 13
    12dc:	0e 94 1c 15 	call	0x2a38	; 0x2a38 <__ashrdi3>
    12e0:	92 2e       	mov	r9, r18
    12e2:	83 2e       	mov	r8, r19
    12e4:	74 2e       	mov	r7, r20
    12e6:	65 2e       	mov	r6, r21
    12e8:	56 2e       	mov	r5, r22
    12ea:	47 2e       	mov	r4, r23
    12ec:	38 2e       	mov	r3, r24
    12ee:	29 2e       	mov	r2, r25
    12f0:	30 91 55 03 	lds	r19, 0x0355	; 0x800355 <bme+0x26>
    12f4:	20 91 54 03 	lds	r18, 0x0354	; 0x800354 <bme+0x25>
    12f8:	93 2f       	mov	r25, r19
    12fa:	99 0f       	add	r25, r25
    12fc:	99 0b       	sbc	r25, r25
    12fe:	a9 2c       	mov	r10, r9
    1300:	b8 2c       	mov	r11, r8
    1302:	c7 2c       	mov	r12, r7
    1304:	d6 2c       	mov	r13, r6
    1306:	e5 2c       	mov	r14, r5
    1308:	f4 2c       	mov	r15, r4
    130a:	03 2d       	mov	r16, r3
    130c:	12 2d       	mov	r17, r2
    130e:	49 2f       	mov	r20, r25
    1310:	59 2f       	mov	r21, r25
    1312:	69 2f       	mov	r22, r25
    1314:	79 2f       	mov	r23, r25
    1316:	89 2f       	mov	r24, r25
    1318:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    131c:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    1320:	09 e1       	ldi	r16, 0x19	; 25
    1322:	0e 94 1c 15 	call	0x2a38	; 0x2a38 <__ashrdi3>
    var2 = (((int64_t)_bme280_calib.dig_P8) * p) >> 19;

    p = ((p + var1 + var2) >> 8) + (((int64_t)_bme280_calib.dig_P7)<<4);
    1326:	a8 84       	ldd	r10, Y+8	; 0x08
    1328:	bf 80       	ldd	r11, Y+7	; 0x07
    132a:	c9 80       	ldd	r12, Y+1	; 0x01
    132c:	da 80       	ldd	r13, Y+2	; 0x02
    132e:	eb 80       	ldd	r14, Y+3	; 0x03
    1330:	fc 80       	ldd	r15, Y+4	; 0x04
    1332:	0d 81       	ldd	r16, Y+5	; 0x05
    1334:	1e 81       	ldd	r17, Y+6	; 0x06
    1336:	0e 94 39 15 	call	0x2a72	; 0x2a72 <__adddi3>
    133a:	19 01       	movw	r2, r18
    133c:	2a 01       	movw	r4, r20
    133e:	3b 01       	movw	r6, r22
    1340:	4c 01       	movw	r8, r24
        return 0; // avoid exception caused by division by zero
    }
    p = 1048576 - adc_P;
    p = (((p<<31) - var2)*3125) / var1;
    var1 = (((int64_t)_bme280_calib.dig_P9) * (p>>13) * (p>>13)) >> 25;
    var2 = (((int64_t)_bme280_calib.dig_P8) * p) >> 19;
    1342:	30 91 53 03 	lds	r19, 0x0353	; 0x800353 <bme+0x24>
    1346:	20 91 52 03 	lds	r18, 0x0352	; 0x800352 <bme+0x23>
    134a:	93 2f       	mov	r25, r19
    134c:	99 0f       	add	r25, r25
    134e:	99 0b       	sbc	r25, r25
    1350:	49 2f       	mov	r20, r25
    1352:	59 2f       	mov	r21, r25
    1354:	69 2f       	mov	r22, r25
    1356:	79 2f       	mov	r23, r25
    1358:	89 2f       	mov	r24, r25
    135a:	0e 94 d4 13 	call	0x27a8	; 0x27a8 <__muldi3>
    135e:	03 e1       	ldi	r16, 0x13	; 19
    1360:	0e 94 1c 15 	call	0x2a38	; 0x2a38 <__ashrdi3>
    1364:	59 01       	movw	r10, r18
    1366:	6a 01       	movw	r12, r20
    1368:	7b 01       	movw	r14, r22
    136a:	8c 01       	movw	r16, r24

    p = ((p + var1 + var2) >> 8) + (((int64_t)_bme280_calib.dig_P7)<<4);
    136c:	91 01       	movw	r18, r2
    136e:	a2 01       	movw	r20, r4
    1370:	b3 01       	movw	r22, r6
    1372:	c4 01       	movw	r24, r8
    1374:	0e 94 39 15 	call	0x2a72	; 0x2a72 <__adddi3>
    1378:	08 e0       	ldi	r16, 0x08	; 8
    137a:	0e 94 1c 15 	call	0x2a38	; 0x2a38 <__ashrdi3>
    137e:	59 01       	movw	r10, r18
    1380:	6a 01       	movw	r12, r20
    1382:	7b 01       	movw	r14, r22
    1384:	e8 2f       	mov	r30, r24
    1386:	19 2f       	mov	r17, r25
    1388:	30 91 51 03 	lds	r19, 0x0351	; 0x800351 <bme+0x22>
    138c:	20 91 50 03 	lds	r18, 0x0350	; 0x800350 <bme+0x21>
    1390:	93 2f       	mov	r25, r19
    1392:	99 0f       	add	r25, r25
    1394:	99 0b       	sbc	r25, r25
    1396:	49 2f       	mov	r20, r25
    1398:	59 2f       	mov	r21, r25
    139a:	69 2f       	mov	r22, r25
    139c:	79 2f       	mov	r23, r25
    139e:	89 2f       	mov	r24, r25
    13a0:	04 e0       	ldi	r16, 0x04	; 4
    13a2:	0e 94 03 15 	call	0x2a06	; 0x2a06 <__ashldi3>
    13a6:	0e 2f       	mov	r16, r30
    13a8:	0e 94 39 15 	call	0x2a72	; 0x2a72 <__adddi3>
    return (float)p/256;
    13ac:	0e 94 8d 10 	call	0x211a	; 0x211a <__floatdisf>
    13b0:	20 e0       	ldi	r18, 0x00	; 0
    13b2:	30 e0       	ldi	r19, 0x00	; 0
    13b4:	40 e8       	ldi	r20, 0x80	; 128
    13b6:	5b e3       	ldi	r21, 0x3B	; 59
    13b8:	0e 94 98 11 	call	0x2330	; 0x2330 <__mulsf3>
}
    13bc:	68 96       	adiw	r28, 0x18	; 24
    13be:	0f b6       	in	r0, 0x3f	; 63
    13c0:	f8 94       	cli
    13c2:	de bf       	out	0x3e, r29	; 62
    13c4:	0f be       	out	0x3f, r0	; 63
    13c6:	cd bf       	out	0x3d, r28	; 61
    13c8:	df 91       	pop	r29
    13ca:	cf 91       	pop	r28
    13cc:	1f 91       	pop	r17
    13ce:	0f 91       	pop	r16
    13d0:	ff 90       	pop	r15
    13d2:	ef 90       	pop	r14
    13d4:	df 90       	pop	r13
    13d6:	cf 90       	pop	r12
    13d8:	bf 90       	pop	r11
    13da:	af 90       	pop	r10
    13dc:	9f 90       	pop	r9
    13de:	8f 90       	pop	r8
    13e0:	7f 90       	pop	r7
    13e2:	6f 90       	pop	r6
    13e4:	5f 90       	pop	r5
    13e6:	4f 90       	pop	r4
    13e8:	3f 90       	pop	r3
    13ea:	2f 90       	pop	r2
    13ec:	08 95       	ret

    readTemperature(); // must be done first to get t_fine

    int32_t adc_P = read24(BME280_REGISTER_PRESSUREDATA);
    if (adc_P == 0x800000) // value in case pressure measurement was disabled
        return NAN;
    13ee:	60 e0       	ldi	r22, 0x00	; 0
    13f0:	70 e0       	ldi	r23, 0x00	; 0
    13f2:	80 ec       	ldi	r24, 0xC0	; 192
    13f4:	9f e7       	ldi	r25, 0x7F	; 127
    13f6:	e2 cf       	rjmp	.-60     	; 0x13bc <_ZN15Adafruit_BME28012readPressureEv.constprop.6+0x39a>
    var1 = ((var1 * var1 * (int64_t)_bme280_calib.dig_P3)>>8) +
           ((var1 * (int64_t)_bme280_calib.dig_P2)<<12);
    var1 = (((((int64_t)1)<<47)+var1))*((int64_t)_bme280_calib.dig_P1)>>33;

    if (var1 == 0) {
        return 0; // avoid exception caused by division by zero
    13f8:	60 e0       	ldi	r22, 0x00	; 0
    13fa:	70 e0       	ldi	r23, 0x00	; 0
    13fc:	cb 01       	movw	r24, r22
    13fe:	de cf       	rjmp	.-68     	; 0x13bc <_ZN15Adafruit_BME28012readPressureEv.constprop.6+0x39a>

00001400 <__vector_19>:
#elif defined(USART_UDRE_vect)
ISR(USART_UDRE_vect)
#else
  #error "Don't know what the Data Register Empty vector is called for Serial"
#endif
{
    1400:	1f 92       	push	r1
    1402:	0f 92       	push	r0
    1404:	0f b6       	in	r0, 0x3f	; 63
    1406:	0f 92       	push	r0
    1408:	11 24       	eor	r1, r1
    140a:	2f 93       	push	r18
    140c:	3f 93       	push	r19
    140e:	4f 93       	push	r20
    1410:	5f 93       	push	r21
    1412:	6f 93       	push	r22
    1414:	7f 93       	push	r23
    1416:	8f 93       	push	r24
    1418:	9f 93       	push	r25
    141a:	af 93       	push	r26
    141c:	bf 93       	push	r27
    141e:	ef 93       	push	r30
    1420:	ff 93       	push	r31
  Serial._tx_udr_empty_irq();
    1422:	86 e8       	ldi	r24, 0x86	; 134
    1424:	92 e0       	ldi	r25, 0x02	; 2
    1426:	0e 94 56 01 	call	0x2ac	; 0x2ac <_ZN14HardwareSerial17_tx_udr_empty_irqEv>
}
    142a:	ff 91       	pop	r31
    142c:	ef 91       	pop	r30
    142e:	bf 91       	pop	r27
    1430:	af 91       	pop	r26
    1432:	9f 91       	pop	r25
    1434:	8f 91       	pop	r24
    1436:	7f 91       	pop	r23
    1438:	6f 91       	pop	r22
    143a:	5f 91       	pop	r21
    143c:	4f 91       	pop	r20
    143e:	3f 91       	pop	r19
    1440:	2f 91       	pop	r18
    1442:	0f 90       	pop	r0
    1444:	0f be       	out	0x3f, r0	; 63
    1446:	0f 90       	pop	r0
    1448:	1f 90       	pop	r1
    144a:	18 95       	reti

0000144c <__vector_18>:
#elif defined(USART_RXC_vect)
  ISR(USART_RXC_vect) // ATmega8
#else
  #error "Don't know what the Data Received vector is called for Serial"
#endif
  {
    144c:	1f 92       	push	r1
    144e:	0f 92       	push	r0
    1450:	0f b6       	in	r0, 0x3f	; 63
    1452:	0f 92       	push	r0
    1454:	11 24       	eor	r1, r1
    1456:	2f 93       	push	r18
    1458:	8f 93       	push	r24
    145a:	9f 93       	push	r25
    145c:	ef 93       	push	r30
    145e:	ff 93       	push	r31

// Actual interrupt handlers //////////////////////////////////////////////////////////////

void HardwareSerial::_rx_complete_irq(void)
{
  if (bit_is_clear(*_ucsra, UPE0)) {
    1460:	e0 91 96 02 	lds	r30, 0x0296	; 0x800296 <Serial+0x10>
    1464:	f0 91 97 02 	lds	r31, 0x0297	; 0x800297 <Serial+0x11>
    1468:	80 81       	ld	r24, Z
    146a:	e0 91 9c 02 	lds	r30, 0x029C	; 0x80029c <Serial+0x16>
    146e:	f0 91 9d 02 	lds	r31, 0x029D	; 0x80029d <Serial+0x17>
    1472:	82 fd       	sbrc	r24, 2
    1474:	1b c0       	rjmp	.+54     	; 0x14ac <__vector_18+0x60>
    // No Parity error, read byte and store it in the buffer if there is
    // room
    unsigned char c = *_udr;
    1476:	90 81       	ld	r25, Z
    rx_buffer_index_t i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE;
    1478:	80 91 9f 02 	lds	r24, 0x029F	; 0x80029f <Serial+0x19>
    147c:	8f 5f       	subi	r24, 0xFF	; 255
    147e:	8f 73       	andi	r24, 0x3F	; 63

    // if we should be storing the received character into the location
    // just before the tail (meaning that the head would advance to the
    // current location of the tail), we're about to overflow the buffer
    // and so we don't write the character or advance the head.
    if (i != _rx_buffer_tail) {
    1480:	20 91 a0 02 	lds	r18, 0x02A0	; 0x8002a0 <Serial+0x1a>
    1484:	82 17       	cp	r24, r18
    1486:	41 f0       	breq	.+16     	; 0x1498 <__vector_18+0x4c>
      _rx_buffer[_rx_buffer_head] = c;
    1488:	e0 91 9f 02 	lds	r30, 0x029F	; 0x80029f <Serial+0x19>
    148c:	f0 e0       	ldi	r31, 0x00	; 0
    148e:	ea 57       	subi	r30, 0x7A	; 122
    1490:	fd 4f       	sbci	r31, 0xFD	; 253
    1492:	95 8f       	std	Z+29, r25	; 0x1d
      _rx_buffer_head = i;
    1494:	80 93 9f 02 	sts	0x029F, r24	; 0x80029f <Serial+0x19>
    Serial._rx_complete_irq();
  }
    1498:	ff 91       	pop	r31
    149a:	ef 91       	pop	r30
    149c:	9f 91       	pop	r25
    149e:	8f 91       	pop	r24
    14a0:	2f 91       	pop	r18
    14a2:	0f 90       	pop	r0
    14a4:	0f be       	out	0x3f, r0	; 63
    14a6:	0f 90       	pop	r0
    14a8:	1f 90       	pop	r1
    14aa:	18 95       	reti
    }
  } else {
    // Parity error, read byte but discard it
    *_udr;
    14ac:	80 81       	ld	r24, Z
    14ae:	f4 cf       	rjmp	.-24     	; 0x1498 <__vector_18+0x4c>

000014b0 <__vector_16>:
#if defined(TIM0_OVF_vect)
ISR(TIM0_OVF_vect)
#else
ISR(TIMER0_OVF_vect)
#endif
{
    14b0:	1f 92       	push	r1
    14b2:	0f 92       	push	r0
    14b4:	0f b6       	in	r0, 0x3f	; 63
    14b6:	0f 92       	push	r0
    14b8:	11 24       	eor	r1, r1
    14ba:	2f 93       	push	r18
    14bc:	3f 93       	push	r19
    14be:	8f 93       	push	r24
    14c0:	9f 93       	push	r25
    14c2:	af 93       	push	r26
    14c4:	bf 93       	push	r27
	// copy these to local variables so they can be stored in registers
	// (volatile variables must be read from memory on every access)
	unsigned long m = timer0_millis;
    14c6:	80 91 6c 02 	lds	r24, 0x026C	; 0x80026c <timer0_millis>
    14ca:	90 91 6d 02 	lds	r25, 0x026D	; 0x80026d <timer0_millis+0x1>
    14ce:	a0 91 6e 02 	lds	r26, 0x026E	; 0x80026e <timer0_millis+0x2>
    14d2:	b0 91 6f 02 	lds	r27, 0x026F	; 0x80026f <timer0_millis+0x3>
	unsigned char f = timer0_fract;
    14d6:	30 91 6b 02 	lds	r19, 0x026B	; 0x80026b <timer0_fract>

	m += MILLIS_INC;
	f += FRACT_INC;
    14da:	23 e0       	ldi	r18, 0x03	; 3
    14dc:	23 0f       	add	r18, r19
	if (f >= FRACT_MAX) {
    14de:	2d 37       	cpi	r18, 0x7D	; 125
    14e0:	58 f5       	brcc	.+86     	; 0x1538 <__vector_16+0x88>
	// copy these to local variables so they can be stored in registers
	// (volatile variables must be read from memory on every access)
	unsigned long m = timer0_millis;
	unsigned char f = timer0_fract;

	m += MILLIS_INC;
    14e2:	01 96       	adiw	r24, 0x01	; 1
    14e4:	a1 1d       	adc	r26, r1
    14e6:	b1 1d       	adc	r27, r1
	if (f >= FRACT_MAX) {
		f -= FRACT_MAX;
		m += 1;
	}

	timer0_fract = f;
    14e8:	20 93 6b 02 	sts	0x026B, r18	; 0x80026b <timer0_fract>
	timer0_millis = m;
    14ec:	80 93 6c 02 	sts	0x026C, r24	; 0x80026c <timer0_millis>
    14f0:	90 93 6d 02 	sts	0x026D, r25	; 0x80026d <timer0_millis+0x1>
    14f4:	a0 93 6e 02 	sts	0x026E, r26	; 0x80026e <timer0_millis+0x2>
    14f8:	b0 93 6f 02 	sts	0x026F, r27	; 0x80026f <timer0_millis+0x3>
	timer0_overflow_count++;
    14fc:	80 91 70 02 	lds	r24, 0x0270	; 0x800270 <timer0_overflow_count>
    1500:	90 91 71 02 	lds	r25, 0x0271	; 0x800271 <timer0_overflow_count+0x1>
    1504:	a0 91 72 02 	lds	r26, 0x0272	; 0x800272 <timer0_overflow_count+0x2>
    1508:	b0 91 73 02 	lds	r27, 0x0273	; 0x800273 <timer0_overflow_count+0x3>
    150c:	01 96       	adiw	r24, 0x01	; 1
    150e:	a1 1d       	adc	r26, r1
    1510:	b1 1d       	adc	r27, r1
    1512:	80 93 70 02 	sts	0x0270, r24	; 0x800270 <timer0_overflow_count>
    1516:	90 93 71 02 	sts	0x0271, r25	; 0x800271 <timer0_overflow_count+0x1>
    151a:	a0 93 72 02 	sts	0x0272, r26	; 0x800272 <timer0_overflow_count+0x2>
    151e:	b0 93 73 02 	sts	0x0273, r27	; 0x800273 <timer0_overflow_count+0x3>
}
    1522:	bf 91       	pop	r27
    1524:	af 91       	pop	r26
    1526:	9f 91       	pop	r25
    1528:	8f 91       	pop	r24
    152a:	3f 91       	pop	r19
    152c:	2f 91       	pop	r18
    152e:	0f 90       	pop	r0
    1530:	0f be       	out	0x3f, r0	; 63
    1532:	0f 90       	pop	r0
    1534:	1f 90       	pop	r1
    1536:	18 95       	reti
	unsigned char f = timer0_fract;

	m += MILLIS_INC;
	f += FRACT_INC;
	if (f >= FRACT_MAX) {
		f -= FRACT_MAX;
    1538:	26 e8       	ldi	r18, 0x86	; 134
    153a:	23 0f       	add	r18, r19
		m += 1;
    153c:	02 96       	adiw	r24, 0x02	; 2
    153e:	a1 1d       	adc	r26, r1
    1540:	b1 1d       	adc	r27, r1
    1542:	d2 cf       	rjmp	.-92     	; 0x14e8 <__vector_16+0x38>

00001544 <__vector_24>:
  // update twi state
  twi_state = TWI_READY;
}

ISR(TWI_vect)
{
    1544:	1f 92       	push	r1
    1546:	0f 92       	push	r0
    1548:	0f b6       	in	r0, 0x3f	; 63
    154a:	0f 92       	push	r0
    154c:	11 24       	eor	r1, r1
    154e:	2f 93       	push	r18
    1550:	3f 93       	push	r19
    1552:	4f 93       	push	r20
    1554:	5f 93       	push	r21
    1556:	6f 93       	push	r22
    1558:	7f 93       	push	r23
    155a:	8f 93       	push	r24
    155c:	9f 93       	push	r25
    155e:	af 93       	push	r26
    1560:	bf 93       	push	r27
    1562:	ef 93       	push	r30
    1564:	ff 93       	push	r31
  switch(TW_STATUS){
    1566:	80 91 b9 00 	lds	r24, 0x00B9	; 0x8000b9 <__TEXT_REGION_LENGTH__+0x7e00b9>
    156a:	88 7f       	andi	r24, 0xF8	; 248
    156c:	80 36       	cpi	r24, 0x60	; 96
    156e:	09 f4       	brne	.+2      	; 0x1572 <__vector_24+0x2e>
    1570:	4a c0       	rjmp	.+148    	; 0x1606 <__vector_24+0xc2>
    1572:	f0 f5       	brcc	.+124    	; 0x15f0 <__vector_24+0xac>
    1574:	88 32       	cpi	r24, 0x28	; 40
    1576:	09 f4       	brne	.+2      	; 0x157a <__vector_24+0x36>
    1578:	a7 c0       	rjmp	.+334    	; 0x16c8 <__vector_24+0x184>
    157a:	18 f5       	brcc	.+70     	; 0x15c2 <__vector_24+0x7e>
    157c:	80 31       	cpi	r24, 0x10	; 16
    157e:	09 f4       	brne	.+2      	; 0x1582 <__vector_24+0x3e>
    1580:	9b c0       	rjmp	.+310    	; 0x16b8 <__vector_24+0x174>
    1582:	b8 f4       	brcc	.+46     	; 0x15b2 <__vector_24+0x6e>
    1584:	88 23       	and	r24, r24
    1586:	09 f4       	brne	.+2      	; 0x158a <__vector_24+0x46>
    1588:	f9 c0       	rjmp	.+498    	; 0x177c <__vector_24+0x238>
    158a:	88 30       	cpi	r24, 0x08	; 8
    158c:	09 f4       	brne	.+2      	; 0x1590 <__vector_24+0x4c>
    158e:	94 c0       	rjmp	.+296    	; 0x16b8 <__vector_24+0x174>
    case TW_BUS_ERROR: // bus error, illegal stop/start
      twi_error = TW_BUS_ERROR;
      twi_stop();
      break;
  }
}
    1590:	ff 91       	pop	r31
    1592:	ef 91       	pop	r30
    1594:	bf 91       	pop	r27
    1596:	af 91       	pop	r26
    1598:	9f 91       	pop	r25
    159a:	8f 91       	pop	r24
    159c:	7f 91       	pop	r23
    159e:	6f 91       	pop	r22
    15a0:	5f 91       	pop	r21
    15a2:	4f 91       	pop	r20
    15a4:	3f 91       	pop	r19
    15a6:	2f 91       	pop	r18
    15a8:	0f 90       	pop	r0
    15aa:	0f be       	out	0x3f, r0	; 63
    15ac:	0f 90       	pop	r0
    15ae:	1f 90       	pop	r1
    15b0:	18 95       	reti
  twi_state = TWI_READY;
}

ISR(TWI_vect)
{
  switch(TW_STATUS){
    15b2:	88 31       	cpi	r24, 0x18	; 24
    15b4:	09 f4       	brne	.+2      	; 0x15b8 <__vector_24+0x74>
    15b6:	88 c0       	rjmp	.+272    	; 0x16c8 <__vector_24+0x184>
    15b8:	80 32       	cpi	r24, 0x20	; 32
    15ba:	51 f7       	brne	.-44     	; 0x1590 <__vector_24+0x4c>
    case TW_MT_SLA_NACK:  // address sent, nack received
      twi_error = TW_MT_SLA_NACK;
      twi_stop();
      break;
    case TW_MT_DATA_NACK: // data sent, nack received
      twi_error = TW_MT_DATA_NACK;
    15bc:	80 93 47 02 	sts	0x0247, r24	; 0x800247 <twi_error>
    15c0:	14 c0       	rjmp	.+40     	; 0x15ea <__vector_24+0xa6>
  twi_state = TWI_READY;
}

ISR(TWI_vect)
{
  switch(TW_STATUS){
    15c2:	80 34       	cpi	r24, 0x40	; 64
    15c4:	09 f4       	brne	.+2      	; 0x15c8 <__vector_24+0x84>
    15c6:	9d c0       	rjmp	.+314    	; 0x1702 <__vector_24+0x1be>
    15c8:	40 f4       	brcc	.+16     	; 0x15da <__vector_24+0x96>
    15ca:	80 33       	cpi	r24, 0x30	; 48
    15cc:	b9 f3       	breq	.-18     	; 0x15bc <__vector_24+0x78>
    15ce:	88 33       	cpi	r24, 0x38	; 56
    15d0:	f9 f6       	brne	.-66     	; 0x1590 <__vector_24+0x4c>
    case TW_MT_DATA_NACK: // data sent, nack received
      twi_error = TW_MT_DATA_NACK;
      twi_stop();
      break;
    case TW_MT_ARB_LOST: // lost bus arbitration
      twi_error = TW_MT_ARB_LOST;
    15d2:	80 93 47 02 	sts	0x0247, r24	; 0x800247 <twi_error>
 */
void twi_reply(uint8_t ack)
{
  // transmit master read ready signal, with or without ack
  if(ack){
    TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA);
    15d6:	85 ec       	ldi	r24, 0xC5	; 197
    15d8:	b0 c0       	rjmp	.+352    	; 0x173a <__vector_24+0x1f6>
  twi_state = TWI_READY;
}

ISR(TWI_vect)
{
  switch(TW_STATUS){
    15da:	80 35       	cpi	r24, 0x50	; 80
    15dc:	09 f4       	brne	.+2      	; 0x15e0 <__vector_24+0x9c>
    15de:	85 c0       	rjmp	.+266    	; 0x16ea <__vector_24+0x1a6>
    15e0:	88 35       	cpi	r24, 0x58	; 88
    15e2:	09 f4       	brne	.+2      	; 0x15e6 <__vector_24+0xa2>
    15e4:	96 c0       	rjmp	.+300    	; 0x1712 <__vector_24+0x1ce>
    15e6:	88 34       	cpi	r24, 0x48	; 72
    15e8:	99 f6       	brne	.-90     	; 0x1590 <__vector_24+0x4c>
    // All
    case TW_NO_INFO:   // no state information
      break;
    case TW_BUS_ERROR: // bus error, illegal stop/start
      twi_error = TW_BUS_ERROR;
      twi_stop();
    15ea:	0e 94 23 03 	call	0x646	; 0x646 <twi_stop>
    15ee:	d0 cf       	rjmp	.-96     	; 0x1590 <__vector_24+0x4c>
  twi_state = TWI_READY;
}

ISR(TWI_vect)
{
  switch(TW_STATUS){
    15f0:	88 39       	cpi	r24, 0x98	; 152
    15f2:	09 f4       	brne	.+2      	; 0x15f6 <__vector_24+0xb2>
    15f4:	8c c0       	rjmp	.+280    	; 0x170e <__vector_24+0x1ca>
    15f6:	38 f5       	brcc	.+78     	; 0x1646 <__vector_24+0x102>
    15f8:	88 37       	cpi	r24, 0x78	; 120
    15fa:	29 f0       	breq	.+10     	; 0x1606 <__vector_24+0xc2>
    15fc:	50 f4       	brcc	.+20     	; 0x1612 <__vector_24+0xce>
    15fe:	88 36       	cpi	r24, 0x68	; 104
    1600:	11 f0       	breq	.+4      	; 0x1606 <__vector_24+0xc2>
    1602:	80 37       	cpi	r24, 0x70	; 112
    1604:	29 f6       	brne	.-118    	; 0x1590 <__vector_24+0x4c>
    case TW_SR_SLA_ACK:   // addressed, returned ack
    case TW_SR_GCALL_ACK: // addressed generally, returned ack
    case TW_SR_ARB_LOST_SLA_ACK:   // lost arbitration, returned ack
    case TW_SR_ARB_LOST_GCALL_ACK: // lost arbitration, returned ack
      // enter slave receiver mode
      twi_state = TWI_SRX;
    1606:	83 e0       	ldi	r24, 0x03	; 3
    1608:	80 93 7b 02 	sts	0x027B, r24	; 0x80027b <twi_state>
      // indicate that rx buffer can be overwritten and ack
      twi_rxBufferIndex = 0;
    160c:	10 92 46 02 	sts	0x0246, r1	; 0x800246 <twi_rxBufferIndex>
    1610:	57 c0       	rjmp	.+174    	; 0x16c0 <__vector_24+0x17c>
  twi_state = TWI_READY;
}

ISR(TWI_vect)
{
  switch(TW_STATUS){
    1612:	88 38       	cpi	r24, 0x88	; 136
    1614:	09 f4       	brne	.+2      	; 0x1618 <__vector_24+0xd4>
    1616:	7b c0       	rjmp	.+246    	; 0x170e <__vector_24+0x1ca>
    1618:	80 39       	cpi	r24, 0x90	; 144
    161a:	19 f0       	breq	.+6      	; 0x1622 <__vector_24+0xde>
    161c:	80 38       	cpi	r24, 0x80	; 128
    161e:	09 f0       	breq	.+2      	; 0x1622 <__vector_24+0xde>
    1620:	b7 cf       	rjmp	.-146    	; 0x1590 <__vector_24+0x4c>
      twi_reply(1);
      break;
    case TW_SR_DATA_ACK:       // data received, returned ack
    case TW_SR_GCALL_DATA_ACK: // data received generally, returned ack
      // if there is still room in the rx buffer
      if(twi_rxBufferIndex < TWI_BUFFER_LENGTH){
    1622:	80 91 46 02 	lds	r24, 0x0246	; 0x800246 <twi_rxBufferIndex>
    1626:	80 32       	cpi	r24, 0x20	; 32
    1628:	08 f0       	brcs	.+2      	; 0x162c <__vector_24+0xe8>
    162a:	71 c0       	rjmp	.+226    	; 0x170e <__vector_24+0x1ca>
        // put byte in buffer and ack
        twi_rxBuffer[twi_rxBufferIndex++] = TWDR;
    162c:	e0 91 46 02 	lds	r30, 0x0246	; 0x800246 <twi_rxBufferIndex>
    1630:	81 e0       	ldi	r24, 0x01	; 1
    1632:	8e 0f       	add	r24, r30
    1634:	80 93 46 02 	sts	0x0246, r24	; 0x800246 <twi_rxBufferIndex>
    1638:	80 91 bb 00 	lds	r24, 0x00BB	; 0x8000bb <__TEXT_REGION_LENGTH__+0x7e00bb>
    163c:	f0 e0       	ldi	r31, 0x00	; 0
    163e:	ea 5d       	subi	r30, 0xDA	; 218
    1640:	fd 4f       	sbci	r31, 0xFD	; 253
    1642:	80 83       	st	Z, r24
    1644:	3d c0       	rjmp	.+122    	; 0x16c0 <__vector_24+0x17c>
  twi_state = TWI_READY;
}

ISR(TWI_vect)
{
  switch(TW_STATUS){
    1646:	80 3b       	cpi	r24, 0xB0	; 176
    1648:	39 f0       	breq	.+14     	; 0x1658 <__vector_24+0x114>
    164a:	e0 f4       	brcc	.+56     	; 0x1684 <__vector_24+0x140>
    164c:	80 3a       	cpi	r24, 0xA0	; 160
    164e:	09 f4       	brne	.+2      	; 0x1652 <__vector_24+0x10e>
    1650:	79 c0       	rjmp	.+242    	; 0x1744 <__vector_24+0x200>
    1652:	88 3a       	cpi	r24, 0xA8	; 168
    1654:	09 f0       	breq	.+2      	; 0x1658 <__vector_24+0x114>
    1656:	9c cf       	rjmp	.-200    	; 0x1590 <__vector_24+0x4c>
    
    // Slave Transmitter
    case TW_ST_SLA_ACK:          // addressed, returned ack
    case TW_ST_ARB_LOST_SLA_ACK: // arbitration lost, returned ack
      // enter slave transmitter mode
      twi_state = TWI_STX;
    1658:	84 e0       	ldi	r24, 0x04	; 4
    165a:	80 93 7b 02 	sts	0x027B, r24	; 0x80027b <twi_state>
      // ready the tx buffer index for iteration
      twi_txBufferIndex = 0;
    165e:	10 92 25 02 	sts	0x0225, r1	; 0x800225 <twi_txBufferIndex>
      // set tx buffer length to be zero, to verify if user changes it
      twi_txBufferLength = 0;
    1662:	10 92 24 02 	sts	0x0224, r1	; 0x800224 <twi_txBufferLength>
      // request for txBuffer to be filled and length to be set
      // note: user must call twi_transmit(bytes, length) to do this
      twi_onSlaveTransmit();
    1666:	e0 91 77 02 	lds	r30, 0x0277	; 0x800277 <twi_onSlaveTransmit>
    166a:	f0 91 78 02 	lds	r31, 0x0278	; 0x800278 <twi_onSlaveTransmit+0x1>
    166e:	09 95       	icall
      // if they didn't change buffer & length, initialize it
      if(0 == twi_txBufferLength){
    1670:	80 91 24 02 	lds	r24, 0x0224	; 0x800224 <twi_txBufferLength>
    1674:	81 11       	cpse	r24, r1
    1676:	0f c0       	rjmp	.+30     	; 0x1696 <__vector_24+0x152>
        twi_txBufferLength = 1;
    1678:	81 e0       	ldi	r24, 0x01	; 1
    167a:	80 93 24 02 	sts	0x0224, r24	; 0x800224 <twi_txBufferLength>
        twi_txBuffer[0] = 0x00;
    167e:	10 92 04 02 	sts	0x0204, r1	; 0x800204 <twi_txBuffer>
    1682:	09 c0       	rjmp	.+18     	; 0x1696 <__vector_24+0x152>
  twi_state = TWI_READY;
}

ISR(TWI_vect)
{
  switch(TW_STATUS){
    1684:	80 3c       	cpi	r24, 0xC0	; 192
    1686:	09 f4       	brne	.+2      	; 0x168a <__vector_24+0x146>
    1688:	a6 cf       	rjmp	.-180    	; 0x15d6 <__vector_24+0x92>
    168a:	88 3c       	cpi	r24, 0xC8	; 200
    168c:	09 f4       	brne	.+2      	; 0x1690 <__vector_24+0x14c>
    168e:	a3 cf       	rjmp	.-186    	; 0x15d6 <__vector_24+0x92>
    1690:	88 3b       	cpi	r24, 0xB8	; 184
    1692:	09 f0       	breq	.+2      	; 0x1696 <__vector_24+0x152>
    1694:	7d cf       	rjmp	.-262    	; 0x1590 <__vector_24+0x4c>
      }
      __attribute__ ((fallthrough));		  
      // transmit first byte from buffer, fall
    case TW_ST_DATA_ACK: // byte sent, ack returned
      // copy data to output register
      TWDR = twi_txBuffer[twi_txBufferIndex++];
    1696:	e0 91 25 02 	lds	r30, 0x0225	; 0x800225 <twi_txBufferIndex>
    169a:	81 e0       	ldi	r24, 0x01	; 1
    169c:	8e 0f       	add	r24, r30
    169e:	80 93 25 02 	sts	0x0225, r24	; 0x800225 <twi_txBufferIndex>
    16a2:	f0 e0       	ldi	r31, 0x00	; 0
    16a4:	ec 5f       	subi	r30, 0xFC	; 252
    16a6:	fd 4f       	sbci	r31, 0xFD	; 253
    16a8:	80 81       	ld	r24, Z
    16aa:	80 93 bb 00 	sts	0x00BB, r24	; 0x8000bb <__TEXT_REGION_LENGTH__+0x7e00bb>
      // if there is more to send, ack, otherwise nack
      if(twi_txBufferIndex < twi_txBufferLength){
    16ae:	90 91 25 02 	lds	r25, 0x0225	; 0x800225 <twi_txBufferIndex>
    16b2:	80 91 24 02 	lds	r24, 0x0224	; 0x800224 <twi_txBufferLength>
    16b6:	29 c0       	rjmp	.+82     	; 0x170a <__vector_24+0x1c6>
  switch(TW_STATUS){
    // All Master
    case TW_START:     // sent start condition
    case TW_REP_START: // sent repeated start condition
      // copy device address and r/w bit to output register and ack
      TWDR = twi_slarw;
    16b8:	80 91 6a 02 	lds	r24, 0x026A	; 0x80026a <twi_slarw>
    case TW_MT_SLA_ACK:  // slave receiver acked address
    case TW_MT_DATA_ACK: // slave receiver acked data
      // if there is data to send, send it, otherwise stop 
      if(twi_masterBufferIndex < twi_masterBufferLength){
        // copy data to output register and ack
        TWDR = twi_masterBuffer[twi_masterBufferIndex++];
    16bc:	80 93 bb 00 	sts	0x00BB, r24	; 0x8000bb <__TEXT_REGION_LENGTH__+0x7e00bb>
 */
void twi_reply(uint8_t ack)
{
  // transmit master read ready signal, with or without ack
  if(ack){
    TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA);
    16c0:	85 ec       	ldi	r24, 0xC5	; 197
  }else{
	  TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT);
    16c2:	80 93 bc 00 	sts	0x00BC, r24	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>
    16c6:	64 cf       	rjmp	.-312    	; 0x1590 <__vector_24+0x4c>

    // Master Transmitter
    case TW_MT_SLA_ACK:  // slave receiver acked address
    case TW_MT_DATA_ACK: // slave receiver acked data
      // if there is data to send, send it, otherwise stop 
      if(twi_masterBufferIndex < twi_masterBufferLength){
    16c8:	90 91 69 02 	lds	r25, 0x0269	; 0x800269 <twi_masterBufferIndex>
    16cc:	80 91 68 02 	lds	r24, 0x0268	; 0x800268 <twi_masterBufferLength>
    16d0:	98 17       	cp	r25, r24
    16d2:	58 f5       	brcc	.+86     	; 0x172a <__vector_24+0x1e6>
        // copy data to output register and ack
        TWDR = twi_masterBuffer[twi_masterBufferIndex++];
    16d4:	e0 91 69 02 	lds	r30, 0x0269	; 0x800269 <twi_masterBufferIndex>
    16d8:	81 e0       	ldi	r24, 0x01	; 1
    16da:	8e 0f       	add	r24, r30
    16dc:	80 93 69 02 	sts	0x0269, r24	; 0x800269 <twi_masterBufferIndex>
    16e0:	f0 e0       	ldi	r31, 0x00	; 0
    16e2:	e8 5b       	subi	r30, 0xB8	; 184
    16e4:	fd 4f       	sbci	r31, 0xFD	; 253
    16e6:	80 81       	ld	r24, Z
    16e8:	e9 cf       	rjmp	.-46     	; 0x16bc <__vector_24+0x178>
      break;

    // Master Receiver
    case TW_MR_DATA_ACK: // data received, ack sent
      // put byte into buffer
      twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
    16ea:	e0 91 69 02 	lds	r30, 0x0269	; 0x800269 <twi_masterBufferIndex>
    16ee:	81 e0       	ldi	r24, 0x01	; 1
    16f0:	8e 0f       	add	r24, r30
    16f2:	80 93 69 02 	sts	0x0269, r24	; 0x800269 <twi_masterBufferIndex>
    16f6:	80 91 bb 00 	lds	r24, 0x00BB	; 0x8000bb <__TEXT_REGION_LENGTH__+0x7e00bb>
    16fa:	f0 e0       	ldi	r31, 0x00	; 0
    16fc:	e8 5b       	subi	r30, 0xB8	; 184
    16fe:	fd 4f       	sbci	r31, 0xFD	; 253
    1700:	80 83       	st	Z, r24
      __attribute__ ((fallthrough));
    case TW_MR_SLA_ACK:  // address sent, ack received
      // ack if more bytes are expected, otherwise nack
      if(twi_masterBufferIndex < twi_masterBufferLength){
    1702:	90 91 69 02 	lds	r25, 0x0269	; 0x800269 <twi_masterBufferIndex>
    1706:	80 91 68 02 	lds	r24, 0x0268	; 0x800268 <twi_masterBufferLength>
      // transmit first byte from buffer, fall
    case TW_ST_DATA_ACK: // byte sent, ack returned
      // copy data to output register
      TWDR = twi_txBuffer[twi_txBufferIndex++];
      // if there is more to send, ack, otherwise nack
      if(twi_txBufferIndex < twi_txBufferLength){
    170a:	98 17       	cp	r25, r24
    170c:	c8 f2       	brcs	.-78     	; 0x16c0 <__vector_24+0x17c>
{
  // transmit master read ready signal, with or without ack
  if(ack){
    TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA);
  }else{
	  TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT);
    170e:	85 e8       	ldi	r24, 0x85	; 133
    1710:	d8 cf       	rjmp	.-80     	; 0x16c2 <__vector_24+0x17e>
        twi_reply(0);
      }
      break;
    case TW_MR_DATA_NACK: // data received, nack sent
      // put final byte into buffer
      twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
    1712:	e0 91 69 02 	lds	r30, 0x0269	; 0x800269 <twi_masterBufferIndex>
    1716:	81 e0       	ldi	r24, 0x01	; 1
    1718:	8e 0f       	add	r24, r30
    171a:	80 93 69 02 	sts	0x0269, r24	; 0x800269 <twi_masterBufferIndex>
    171e:	80 91 bb 00 	lds	r24, 0x00BB	; 0x8000bb <__TEXT_REGION_LENGTH__+0x7e00bb>
    1722:	f0 e0       	ldi	r31, 0x00	; 0
    1724:	e8 5b       	subi	r30, 0xB8	; 184
    1726:	fd 4f       	sbci	r31, 0xFD	; 253
    1728:	80 83       	st	Z, r24
	if (twi_sendStop)
    172a:	80 91 7a 02 	lds	r24, 0x027A	; 0x80027a <twi_sendStop>
    172e:	81 11       	cpse	r24, r1
    1730:	5c cf       	rjmp	.-328    	; 0x15ea <__vector_24+0xa6>
          twi_stop();
	else {
	  twi_inRepStart = true;	// we're gonna send the START
    1732:	81 e0       	ldi	r24, 0x01	; 1
    1734:	80 93 79 02 	sts	0x0279, r24	; 0x800279 <twi_inRepStart>
	  // don't enable the interrupt. We'll generate the start, but we 
	  // avoid handling the interrupt until we're in the next transaction,
	  // at the point where we would normally issue the start.
	  TWCR = _BV(TWINT) | _BV(TWSTA)| _BV(TWEN) ;
    1738:	84 ea       	ldi	r24, 0xA4	; 164
 */
void twi_reply(uint8_t ack)
{
  // transmit master read ready signal, with or without ack
  if(ack){
    TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA);
    173a:	80 93 bc 00 	sts	0x00BC, r24	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>
    case TW_ST_DATA_NACK: // received nack, we are done 
    case TW_ST_LAST_DATA: // received ack, but we are done already!
      // ack future responses
      twi_reply(1);
      // leave slave receiver state
      twi_state = TWI_READY;
    173e:	10 92 7b 02 	sts	0x027B, r1	; 0x80027b <twi_state>
    1742:	26 cf       	rjmp	.-436    	; 0x1590 <__vector_24+0x4c>
 * Output   none
 */
void twi_releaseBus(void)
{
  // release bus
  TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT);
    1744:	85 ec       	ldi	r24, 0xC5	; 197
    1746:	80 93 bc 00 	sts	0x00BC, r24	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>

  // update twi state
  twi_state = TWI_READY;
    174a:	10 92 7b 02 	sts	0x027B, r1	; 0x80027b <twi_state>
      break;
    case TW_SR_STOP: // stop or repeated start condition received
      // ack future responses and leave slave receiver state
      twi_releaseBus();
      // put a null char after data if there's room
      if(twi_rxBufferIndex < TWI_BUFFER_LENGTH){
    174e:	80 91 46 02 	lds	r24, 0x0246	; 0x800246 <twi_rxBufferIndex>
    1752:	80 32       	cpi	r24, 0x20	; 32
    1754:	30 f4       	brcc	.+12     	; 0x1762 <__vector_24+0x21e>
        twi_rxBuffer[twi_rxBufferIndex] = '\0';
    1756:	e0 91 46 02 	lds	r30, 0x0246	; 0x800246 <twi_rxBufferIndex>
    175a:	f0 e0       	ldi	r31, 0x00	; 0
    175c:	ea 5d       	subi	r30, 0xDA	; 218
    175e:	fd 4f       	sbci	r31, 0xFD	; 253
    1760:	10 82       	st	Z, r1
      }
      // callback to user defined callback
      twi_onSlaveReceive(twi_rxBuffer, twi_rxBufferIndex);
    1762:	60 91 46 02 	lds	r22, 0x0246	; 0x800246 <twi_rxBufferIndex>
    1766:	70 e0       	ldi	r23, 0x00	; 0
    1768:	e0 91 75 02 	lds	r30, 0x0275	; 0x800275 <twi_onSlaveReceive>
    176c:	f0 91 76 02 	lds	r31, 0x0276	; 0x800276 <twi_onSlaveReceive+0x1>
    1770:	86 e2       	ldi	r24, 0x26	; 38
    1772:	92 e0       	ldi	r25, 0x02	; 2
    1774:	09 95       	icall
      // since we submit rx buffer to "wire" library, we can reset it
      twi_rxBufferIndex = 0;
    1776:	10 92 46 02 	sts	0x0246, r1	; 0x800246 <twi_rxBufferIndex>
    177a:	0a cf       	rjmp	.-492    	; 0x1590 <__vector_24+0x4c>

    // All
    case TW_NO_INFO:   // no state information
      break;
    case TW_BUS_ERROR: // bus error, illegal stop/start
      twi_error = TW_BUS_ERROR;
    177c:	10 92 47 02 	sts	0x0247, r1	; 0x800247 <twi_error>
    1780:	34 cf       	rjmp	.-408    	; 0x15ea <__vector_24+0xa6>

00001782 <_GLOBAL__I_65535_0_bme280test.ino.cpp.o.2183>:
    1782:	e6 e8       	ldi	r30, 0x86	; 134
    1784:	f2 e0       	ldi	r31, 0x02	; 2
    1786:	13 82       	std	Z+3, r1	; 0x03
    1788:	12 82       	std	Z+2, r1	; 0x02
    178a:	88 ee       	ldi	r24, 0xE8	; 232
    178c:	93 e0       	ldi	r25, 0x03	; 3
    178e:	a0 e0       	ldi	r26, 0x00	; 0
    1790:	b0 e0       	ldi	r27, 0x00	; 0
    1792:	84 83       	std	Z+4, r24	; 0x04
    1794:	95 83       	std	Z+5, r25	; 0x05
    1796:	a6 83       	std	Z+6, r26	; 0x06
    1798:	b7 83       	std	Z+7, r27	; 0x07
    179a:	24 e0       	ldi	r18, 0x04	; 4
    179c:	31 e0       	ldi	r19, 0x01	; 1
    179e:	31 83       	std	Z+1, r19	; 0x01
    17a0:	20 83       	st	Z, r18
    17a2:	25 ec       	ldi	r18, 0xC5	; 197
    17a4:	30 e0       	ldi	r19, 0x00	; 0
    17a6:	35 87       	std	Z+13, r19	; 0x0d
    17a8:	24 87       	std	Z+12, r18	; 0x0c
    17aa:	24 ec       	ldi	r18, 0xC4	; 196
    17ac:	30 e0       	ldi	r19, 0x00	; 0
    17ae:	37 87       	std	Z+15, r19	; 0x0f
    17b0:	26 87       	std	Z+14, r18	; 0x0e
    17b2:	20 ec       	ldi	r18, 0xC0	; 192
    17b4:	30 e0       	ldi	r19, 0x00	; 0
    17b6:	31 8b       	std	Z+17, r19	; 0x11
    17b8:	20 8b       	std	Z+16, r18	; 0x10
    17ba:	21 ec       	ldi	r18, 0xC1	; 193
    17bc:	30 e0       	ldi	r19, 0x00	; 0
    17be:	33 8b       	std	Z+19, r19	; 0x13
    17c0:	22 8b       	std	Z+18, r18	; 0x12
    17c2:	22 ec       	ldi	r18, 0xC2	; 194
    17c4:	30 e0       	ldi	r19, 0x00	; 0
    17c6:	35 8b       	std	Z+21, r19	; 0x15
    17c8:	24 8b       	std	Z+20, r18	; 0x14
    17ca:	26 ec       	ldi	r18, 0xC6	; 198
    17cc:	30 e0       	ldi	r19, 0x00	; 0
    17ce:	37 8b       	std	Z+23, r19	; 0x17
    17d0:	26 8b       	std	Z+22, r18	; 0x16
    17d2:	11 8e       	std	Z+25, r1	; 0x19
    17d4:	12 8e       	std	Z+26, r1	; 0x1a
    17d6:	13 8e       	std	Z+27, r1	; 0x1b
    17d8:	14 8e       	std	Z+28, r1	; 0x1c
    17da:	e3 e2       	ldi	r30, 0x23	; 35
    17dc:	f3 e0       	ldi	r31, 0x03	; 3
    17de:	13 82       	std	Z+3, r1	; 0x03
    17e0:	12 82       	std	Z+2, r1	; 0x02
    17e2:	84 83       	std	Z+4, r24	; 0x04
    17e4:	95 83       	std	Z+5, r25	; 0x05
    17e6:	a6 83       	std	Z+6, r26	; 0x06
    17e8:	b7 83       	std	Z+7, r27	; 0x07
    17ea:	86 e1       	ldi	r24, 0x16	; 22
    17ec:	91 e0       	ldi	r25, 0x01	; 1
    17ee:	91 83       	std	Z+1, r25	; 0x01
    17f0:	80 83       	st	Z, r24
    17f2:	ef e2       	ldi	r30, 0x2F	; 47
    17f4:	f3 e0       	ldi	r31, 0x03	; 3
    17f6:	8f ef       	ldi	r24, 0xFF	; 255
    17f8:	83 87       	std	Z+11, r24	; 0x0b
    17fa:	84 87       	std	Z+12, r24	; 0x0c
    17fc:	85 87       	std	Z+13, r24	; 0x0d
    17fe:	86 87       	std	Z+14, r24	; 0x0e
    1800:	08 95       	ret

00001802 <main>:

void init()
{
	// this needs to be called before setup() or some functions won't
	// work there
	sei();
    1802:	78 94       	sei
	
	// on the ATmega168, timer 0 is also used for fast hardware pwm
	// (using phase-correct PWM would mean that timer 0 overflowed half as often
	// resulting in different millis() behavior on the ATmega8 and ATmega168)
#if defined(TCCR0A) && defined(WGM01)
	sbi(TCCR0A, WGM01);
    1804:	84 b5       	in	r24, 0x24	; 36
    1806:	82 60       	ori	r24, 0x02	; 2
    1808:	84 bd       	out	0x24, r24	; 36
	sbi(TCCR0A, WGM00);
    180a:	84 b5       	in	r24, 0x24	; 36
    180c:	81 60       	ori	r24, 0x01	; 1
    180e:	84 bd       	out	0x24, r24	; 36
	// this combination is for the standard atmega8
	sbi(TCCR0, CS01);
	sbi(TCCR0, CS00);
#elif defined(TCCR0B) && defined(CS01) && defined(CS00)
	// this combination is for the standard 168/328/1280/2560
	sbi(TCCR0B, CS01);
    1810:	85 b5       	in	r24, 0x25	; 37
    1812:	82 60       	ori	r24, 0x02	; 2
    1814:	85 bd       	out	0x25, r24	; 37
	sbi(TCCR0B, CS00);
    1816:	85 b5       	in	r24, 0x25	; 37
    1818:	81 60       	ori	r24, 0x01	; 1
    181a:	85 bd       	out	0x25, r24	; 37

	// enable timer 0 overflow interrupt
#if defined(TIMSK) && defined(TOIE0)
	sbi(TIMSK, TOIE0);
#elif defined(TIMSK0) && defined(TOIE0)
	sbi(TIMSK0, TOIE0);
    181c:	80 91 6e 00 	lds	r24, 0x006E	; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e>
    1820:	81 60       	ori	r24, 0x01	; 1
    1822:	80 93 6e 00 	sts	0x006E, r24	; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e>
	// this is better for motors as it ensures an even waveform
	// note, however, that fast pwm mode can achieve a frequency of up
	// 8 MHz (with a 16 MHz clock) at 50% duty cycle

#if defined(TCCR1B) && defined(CS11) && defined(CS10)
	TCCR1B = 0;
    1826:	10 92 81 00 	sts	0x0081, r1	; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>

	// set timer 1 prescale factor to 64
	sbi(TCCR1B, CS11);
    182a:	80 91 81 00 	lds	r24, 0x0081	; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
    182e:	82 60       	ori	r24, 0x02	; 2
    1830:	80 93 81 00 	sts	0x0081, r24	; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
#if F_CPU >= 8000000L
	sbi(TCCR1B, CS10);
    1834:	80 91 81 00 	lds	r24, 0x0081	; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
    1838:	81 60       	ori	r24, 0x01	; 1
    183a:	80 93 81 00 	sts	0x0081, r24	; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
	sbi(TCCR1, CS10);
#endif
#endif
	// put timer 1 in 8-bit phase correct pwm mode
#if defined(TCCR1A) && defined(WGM10)
	sbi(TCCR1A, WGM10);
    183e:	80 91 80 00 	lds	r24, 0x0080	; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
    1842:	81 60       	ori	r24, 0x01	; 1
    1844:	80 93 80 00 	sts	0x0080, r24	; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>

	// set timer 2 prescale factor to 64
#if defined(TCCR2) && defined(CS22)
	sbi(TCCR2, CS22);
#elif defined(TCCR2B) && defined(CS22)
	sbi(TCCR2B, CS22);
    1848:	80 91 b1 00 	lds	r24, 0x00B1	; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1>
    184c:	84 60       	ori	r24, 0x04	; 4
    184e:	80 93 b1 00 	sts	0x00B1, r24	; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1>

	// configure timer 2 for phase correct pwm (8-bit)
#if defined(TCCR2) && defined(WGM20)
	sbi(TCCR2, WGM20);
#elif defined(TCCR2A) && defined(WGM20)
	sbi(TCCR2A, WGM20);
    1852:	80 91 b0 00 	lds	r24, 0x00B0	; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
    1856:	81 60       	ori	r24, 0x01	; 1
    1858:	80 93 b0 00 	sts	0x00B0, r24	; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
#endif

#if defined(ADCSRA)
	// set a2d prescaler so we are inside the desired 50-200 KHz range.
	#if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz
		sbi(ADCSRA, ADPS2);
    185c:	80 91 7a 00 	lds	r24, 0x007A	; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
    1860:	84 60       	ori	r24, 0x04	; 4
    1862:	80 93 7a 00 	sts	0x007A, r24	; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
		sbi(ADCSRA, ADPS1);
    1866:	80 91 7a 00 	lds	r24, 0x007A	; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
    186a:	82 60       	ori	r24, 0x02	; 2
    186c:	80 93 7a 00 	sts	0x007A, r24	; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
		sbi(ADCSRA, ADPS0);
    1870:	80 91 7a 00 	lds	r24, 0x007A	; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
    1874:	81 60       	ori	r24, 0x01	; 1
    1876:	80 93 7a 00 	sts	0x007A, r24	; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
		cbi(ADCSRA, ADPS2);
		cbi(ADCSRA, ADPS1);
		sbi(ADCSRA, ADPS0);
	#endif
	// enable a2d conversions
	sbi(ADCSRA, ADEN);
    187a:	80 91 7a 00 	lds	r24, 0x007A	; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
    187e:	80 68       	ori	r24, 0x80	; 128
    1880:	80 93 7a 00 	sts	0x007A, r24	; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
	// here so they can be used as normal digital i/o; they will be
	// reconnected in Serial.begin()
#if defined(UCSRB)
	UCSRB = 0;
#elif defined(UCSR0B)
	UCSR0B = 0;
    1884:	10 92 c1 00 	sts	0x00C1, r1	; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1>

void HardwareSerial::begin(unsigned long baud, byte config)
{
  // Try u2x mode first
  uint16_t baud_setting = (F_CPU / 4 / baud - 1) / 2;
  *_ucsra = 1 << U2X0;
    1888:	e0 91 96 02 	lds	r30, 0x0296	; 0x800296 <Serial+0x10>
    188c:	f0 91 97 02 	lds	r31, 0x0297	; 0x800297 <Serial+0x11>
    1890:	82 e0       	ldi	r24, 0x02	; 2
    1892:	80 83       	st	Z, r24
    *_ucsra = 0;
    baud_setting = (F_CPU / 8 / baud - 1) / 2;
  }

  // assign the baud_setting, a.k.a. ubrr (USART Baud Rate Register)
  *_ubrrh = baud_setting >> 8;
    1894:	e0 91 92 02 	lds	r30, 0x0292	; 0x800292 <Serial+0xc>
    1898:	f0 91 93 02 	lds	r31, 0x0293	; 0x800293 <Serial+0xd>
    189c:	10 82       	st	Z, r1
  *_ubrrl = baud_setting;
    189e:	e0 91 94 02 	lds	r30, 0x0294	; 0x800294 <Serial+0xe>
    18a2:	f0 91 95 02 	lds	r31, 0x0295	; 0x800295 <Serial+0xf>
    18a6:	8f ec       	ldi	r24, 0xCF	; 207
    18a8:	80 83       	st	Z, r24

  _written = false;
    18aa:	10 92 9e 02 	sts	0x029E, r1	; 0x80029e <Serial+0x18>

  //set the data bits, parity, and stop bits
#if defined(__AVR_ATmega8__)
  config |= 0x80; // select UCSRC register (shared with UBRRH)
#endif
  *_ucsrc = config;
    18ae:	e0 91 9a 02 	lds	r30, 0x029A	; 0x80029a <Serial+0x14>
    18b2:	f0 91 9b 02 	lds	r31, 0x029B	; 0x80029b <Serial+0x15>
    18b6:	86 e0       	ldi	r24, 0x06	; 6
    18b8:	80 83       	st	Z, r24
  
  sbi(*_ucsrb, RXEN0);
    18ba:	e0 91 98 02 	lds	r30, 0x0298	; 0x800298 <Serial+0x12>
    18be:	f0 91 99 02 	lds	r31, 0x0299	; 0x800299 <Serial+0x13>
    18c2:	80 81       	ld	r24, Z
    18c4:	80 61       	ori	r24, 0x10	; 16
    18c6:	80 83       	st	Z, r24
  sbi(*_ucsrb, TXEN0);
    18c8:	e0 91 98 02 	lds	r30, 0x0298	; 0x800298 <Serial+0x12>
    18cc:	f0 91 99 02 	lds	r31, 0x0299	; 0x800299 <Serial+0x13>
    18d0:	80 81       	ld	r24, Z
    18d2:	88 60       	ori	r24, 0x08	; 8
    18d4:	80 83       	st	Z, r24
  sbi(*_ucsrb, RXCIE0);
    18d6:	e0 91 98 02 	lds	r30, 0x0298	; 0x800298 <Serial+0x12>
    18da:	f0 91 99 02 	lds	r31, 0x0299	; 0x800299 <Serial+0x13>
    18de:	80 81       	ld	r24, Z
    18e0:	80 68       	ori	r24, 0x80	; 128
    18e2:	80 83       	st	Z, r24
  cbi(*_ucsrb, UDRIE0);
    18e4:	e0 91 98 02 	lds	r30, 0x0298	; 0x800298 <Serial+0x12>
    18e8:	f0 91 99 02 	lds	r31, 0x0299	; 0x800299 <Serial+0x13>
    18ec:	80 81       	ld	r24, Z
    18ee:	8f 7d       	andi	r24, 0xDF	; 223
    18f0:	80 83       	st	Z, r24
    18f2:	ce ef       	ldi	r28, 0xFE	; 254
    18f4:	d0 e0       	ldi	r29, 0x00	; 0
size_t Print::print(const __FlashStringHelper *ifsh)
{
  PGM_P p = reinterpret_cast<PGM_P>(ifsh);
  size_t n = 0;
  while (1) {
    unsigned char c = pgm_read_byte(p++);
    18f6:	fe 01       	movw	r30, r28
    18f8:	64 91       	lpm	r22, Z
    if (c == 0) break;
    18fa:	66 23       	and	r22, r22
    18fc:	39 f0       	breq	.+14     	; 0x190c <main+0x10a>
    if (write(c)) n++;
    18fe:	86 e8       	ldi	r24, 0x86	; 134
    1900:	92 e0       	ldi	r25, 0x02	; 2
    1902:	0e 94 78 01 	call	0x2f0	; 0x2f0 <_ZN14HardwareSerial5writeEh>
    1906:	21 96       	adiw	r28, 0x01	; 1
    1908:	89 2b       	or	r24, r25
    190a:	a9 f7       	brne	.-22     	; 0x18f6 <main+0xf4>
    190c:	84 e2       	ldi	r24, 0x24	; 36
    190e:	91 e0       	ldi	r25, 0x01	; 1
    1910:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>
    @returns true on success, false otherwise
*/
/**************************************************************************/
bool Adafruit_BME280::begin(void)
{
    _i2caddr = BME280_ADDRESS;
    1914:	86 e7       	ldi	r24, 0x76	; 118
    1916:	80 93 31 03 	sts	0x0331, r24	; 0x800331 <bme+0x2>
	_wire = &Wire;
    191a:	83 e2       	ldi	r24, 0x23	; 35
    191c:	93 e0       	ldi	r25, 0x03	; 3
    191e:	90 93 30 03 	sts	0x0330, r25	; 0x800330 <bme+0x1>
    1922:	80 93 2f 03 	sts	0x032F, r24	; 0x80032f <bme>
*/
/**************************************************************************/
bool Adafruit_BME280::init()
{
    // init I2C or SPI sensor interface
    if (_cs == -1) {
    1926:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
    192a:	8f 3f       	cpi	r24, 0xFF	; 255
    192c:	f1 f5       	brne	.+124    	; 0x19aa <main+0x1a8>

// Public Methods //////////////////////////////////////////////////////////////

void TwoWire::begin(void)
{
  rxBufferIndex = 0;
    192e:	10 92 7d 02 	sts	0x027D, r1	; 0x80027d <_ZN7TwoWire13rxBufferIndexE>
  rxBufferLength = 0;
    1932:	10 92 7c 02 	sts	0x027C, r1	; 0x80027c <_ZN7TwoWire14rxBufferLengthE>

  txBufferIndex = 0;
    1936:	10 92 83 02 	sts	0x0283, r1	; 0x800283 <_ZN7TwoWire13txBufferIndexE>
  txBufferLength = 0;
    193a:	10 92 82 02 	sts	0x0282, r1	; 0x800282 <_ZN7TwoWire14txBufferLengthE>
 * Output   none
 */
void twi_init(void)
{
  // initialize state
  twi_state = TWI_READY;
    193e:	10 92 7b 02 	sts	0x027B, r1	; 0x80027b <twi_state>
  twi_sendStop = true;		// default value
    1942:	81 e0       	ldi	r24, 0x01	; 1
    1944:	80 93 7a 02 	sts	0x027A, r24	; 0x80027a <twi_sendStop>
  twi_inRepStart = false;
    1948:	10 92 79 02 	sts	0x0279, r1	; 0x800279 <twi_inRepStart>
  
  // activate internal pullups for twi.
  digitalWrite(SDA, 1);
    194c:	61 e0       	ldi	r22, 0x01	; 1
    194e:	82 e1       	ldi	r24, 0x12	; 18
    1950:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
  digitalWrite(SCL, 1);
    1954:	61 e0       	ldi	r22, 0x01	; 1
    1956:	83 e1       	ldi	r24, 0x13	; 19
    1958:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>

  // initialize twi prescaler and bit rate
  cbi(TWSR, TWPS0);
    195c:	80 91 b9 00 	lds	r24, 0x00B9	; 0x8000b9 <__TEXT_REGION_LENGTH__+0x7e00b9>
    1960:	8e 7f       	andi	r24, 0xFE	; 254
    1962:	80 93 b9 00 	sts	0x00B9, r24	; 0x8000b9 <__TEXT_REGION_LENGTH__+0x7e00b9>
  cbi(TWSR, TWPS1);
    1966:	80 91 b9 00 	lds	r24, 0x00B9	; 0x8000b9 <__TEXT_REGION_LENGTH__+0x7e00b9>
    196a:	8d 7f       	andi	r24, 0xFD	; 253
    196c:	80 93 b9 00 	sts	0x00B9, r24	; 0x8000b9 <__TEXT_REGION_LENGTH__+0x7e00b9>
  TWBR = ((F_CPU / TWI_FREQ) - 16) / 2;
    1970:	88 e4       	ldi	r24, 0x48	; 72
    1972:	80 93 b8 00 	sts	0x00B8, r24	; 0x8000b8 <__TEXT_REGION_LENGTH__+0x7e00b8>
  SCL Frequency = CPU Clock Frequency / (16 + (2 * TWBR))
  note: TWBR should be 10 or higher for master mode
  It is 72 for a 16mhz Wiring board with 100kHz TWI */

  // enable twi module, acks, and twi interrupt
  TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA);
    1976:	85 e4       	ldi	r24, 0x45	; 69
    1978:	80 93 bc 00 	sts	0x00BC, r24	; 0x8000bc <__TEXT_REGION_LENGTH__+0x7e00bc>
 * Input    function: callback function to use
 * Output   none
 */
void twi_attachSlaveTxEvent( void (*function)(void) )
{
  twi_onSlaveTransmit = function;
    197c:	86 ed       	ldi	r24, 0xD6	; 214
    197e:	90 e0       	ldi	r25, 0x00	; 0
    1980:	90 93 78 02 	sts	0x0278, r25	; 0x800278 <twi_onSlaveTransmit+0x1>
    1984:	80 93 77 02 	sts	0x0277, r24	; 0x800277 <twi_onSlaveTransmit>
 * Input    function: callback function to use
 * Output   none
 */
void twi_attachSlaveRxEvent( void (*function)(uint8_t*, int) )
{
  twi_onSlaveReceive = function;
    1988:	87 ed       	ldi	r24, 0xD7	; 215
    198a:	90 e0       	ldi	r25, 0x00	; 0
    198c:	90 93 76 02 	sts	0x0276, r25	; 0x800276 <twi_onSlaveReceive+0x1>
    1990:	80 93 75 02 	sts	0x0275, r24	; 0x800275 <twi_onSlaveReceive>
            pinMode(_miso, INPUT);
        }
    }

    // check if sensor, i.e. the chip ID is correct
    if (read8(BME280_REGISTER_CHIPID) != 0x60)
    1994:	80 ed       	ldi	r24, 0xD0	; 208
    1996:	0e 94 09 06 	call	0xc12	; 0xc12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>
    199a:	80 36       	cpi	r24, 0x60	; 96
    199c:	09 f4       	brne	.+2      	; 0x19a0 <main+0x19e>
    199e:	54 c0       	rjmp	.+168    	; 0x1a48 <main+0x246>
    
    // default settings
    // (you can also pass in a Wire library object like &Wire2)
    status = bme.begin();  
    if (!status) {
        Serial.println("Could not find a valid BME280 sensor, check wiring!");
    19a0:	83 e3       	ldi	r24, 0x33	; 51
    19a2:	91 e0       	ldi	r25, 0x01	; 1
    19a4:	0e 94 d9 04 	call	0x9b2	; 0x9b2 <_ZN5Print7printlnEPKc.constprop.49>
    19a8:	ff cf       	rjmp	.-2      	; 0x19a8 <main+0x1a6>
    // init I2C or SPI sensor interface
    if (_cs == -1) {
        // I2C
        _wire -> begin();
    } else {
        digitalWrite(_cs, HIGH);
    19aa:	61 e0       	ldi	r22, 0x01	; 1
    19ac:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
        pinMode(_cs, OUTPUT);
    19b0:	61 e0       	ldi	r22, 0x01	; 1
    19b2:	80 91 3a 03 	lds	r24, 0x033A	; 0x80033a <bme+0xb>
    19b6:	0e 94 99 02 	call	0x532	; 0x532 <pinMode>
        if (_sck == -1) {
    19ba:	80 91 3d 03 	lds	r24, 0x033D	; 0x80033d <bme+0xe>
    19be:	8f 3f       	cpi	r24, 0xFF	; 255
    19c0:	09 f0       	breq	.+2      	; 0x19c4 <main+0x1c2>
    19c2:	34 c0       	rjmp	.+104    	; 0x1a2c <main+0x22a>
uint8_t SPIClass::inTransactionFlag = 0;
#endif

void SPIClass::begin()
{
  uint8_t sreg = SREG;
    19c4:	cf b7       	in	r28, 0x3f	; 63
  noInterrupts(); // Protect from a scheduler and prevent transactionBegin
    19c6:	f8 94       	cli
  if (!initialized) {
    19c8:	80 91 74 02 	lds	r24, 0x0274	; 0x800274 <_ZN8SPIClass11initializedE>
    19cc:	81 11       	cpse	r24, r1
    19ce:	27 c0       	rjmp	.+78     	; 0x1a1e <main+0x21c>
    // Set SS to high so a connected chip will be "deselected" by default
    uint8_t port = digitalPinToPort(SS);
    19d0:	ee e1       	ldi	r30, 0x1E	; 30
    19d2:	f1 e0       	ldi	r31, 0x01	; 1
    19d4:	84 91       	lpm	r24, Z
    uint8_t bit = digitalPinToBitMask(SS);
    19d6:	e2 e3       	ldi	r30, 0x32	; 50
    19d8:	f1 e0       	ldi	r31, 0x01	; 1
    19da:	94 91       	lpm	r25, Z
    volatile uint8_t *reg = portModeRegister(port);
    19dc:	e8 2f       	mov	r30, r24
    19de:	f0 e0       	ldi	r31, 0x00	; 0
    19e0:	ee 0f       	add	r30, r30
    19e2:	ff 1f       	adc	r31, r31
    19e4:	ec 50       	subi	r30, 0x0C	; 12
    19e6:	ff 4f       	sbci	r31, 0xFF	; 255
    19e8:	a5 91       	lpm	r26, Z+
    19ea:	b4 91       	lpm	r27, Z

    // if the SS pin is not already configured as an output
    // then set it high (to enable the internal pull-up resistor)
    if(!(*reg & bit)){
    19ec:	ec 91       	ld	r30, X
    19ee:	e9 23       	and	r30, r25
    19f0:	21 f4       	brne	.+8      	; 0x19fa <main+0x1f8>
      digitalWrite(SS, HIGH);
    19f2:	61 e0       	ldi	r22, 0x01	; 1
    19f4:	8a e0       	ldi	r24, 0x0A	; 10
    19f6:	0e 94 0e 02 	call	0x41c	; 0x41c <digitalWrite>
    }

    // When the SS pin is set as OUTPUT, it can be used as
    // a general purpose output port (it doesn't influence
    // SPI operations).
    pinMode(SS, OUTPUT);
    19fa:	61 e0       	ldi	r22, 0x01	; 1
    19fc:	8a e0       	ldi	r24, 0x0A	; 10
    19fe:	0e 94 99 02 	call	0x532	; 0x532 <pinMode>

    // Warning: if the SS pin ever becomes a LOW INPUT then SPI
    // automatically switches to Slave, so the data direction of
    // the SS pin MUST be kept as OUTPUT.
    SPCR |= _BV(MSTR);
    1a02:	8c b5       	in	r24, 0x2c	; 44
    1a04:	80 61       	ori	r24, 0x10	; 16
    1a06:	8c bd       	out	0x2c, r24	; 44
    SPCR |= _BV(SPE);
    1a08:	8c b5       	in	r24, 0x2c	; 44
    1a0a:	80 64       	ori	r24, 0x40	; 64
    1a0c:	8c bd       	out	0x2c, r24	; 44
    // MISO pin automatically overrides to INPUT.
    // By doing this AFTER enabling SPI, we avoid accidentally
    // clocking in a single bit since the lines go directly
    // from "input" to SPI control.
    // http://code.google.com/p/arduino/issues/detail?id=888
    pinMode(SCK, OUTPUT);
    1a0e:	61 e0       	ldi	r22, 0x01	; 1
    1a10:	8d e0       	ldi	r24, 0x0D	; 13
    1a12:	0e 94 99 02 	call	0x532	; 0x532 <pinMode>
    pinMode(MOSI, OUTPUT);
    1a16:	61 e0       	ldi	r22, 0x01	; 1
    1a18:	8b e0       	ldi	r24, 0x0B	; 11
    1a1a:	0e 94 99 02 	call	0x532	; 0x532 <pinMode>
  }
  initialized++; // reference count
    1a1e:	80 91 74 02 	lds	r24, 0x0274	; 0x800274 <_ZN8SPIClass11initializedE>
    1a22:	8f 5f       	subi	r24, 0xFF	; 255
    1a24:	80 93 74 02 	sts	0x0274, r24	; 0x800274 <_ZN8SPIClass11initializedE>
  SREG = sreg;
    1a28:	cf bf       	out	0x3f, r28	; 63
    1a2a:	b4 cf       	rjmp	.-152    	; 0x1994 <main+0x192>
            // hardware SPI
            SPI.begin();
        } else {
            // software SPI
            pinMode(_sck, OUTPUT);
    1a2c:	61 e0       	ldi	r22, 0x01	; 1
    1a2e:	0e 94 99 02 	call	0x532	; 0x532 <pinMode>
            pinMode(_mosi, OUTPUT);
    1a32:	61 e0       	ldi	r22, 0x01	; 1
    1a34:	80 91 3b 03 	lds	r24, 0x033B	; 0x80033b <bme+0xc>
    1a38:	0e 94 99 02 	call	0x532	; 0x532 <pinMode>
            pinMode(_miso, INPUT);
    1a3c:	60 e0       	ldi	r22, 0x00	; 0
    1a3e:	80 91 3c 03 	lds	r24, 0x033C	; 0x80033c <bme+0xd>
    1a42:	0e 94 99 02 	call	0x532	; 0x532 <pinMode>
    1a46:	a6 cf       	rjmp	.-180    	; 0x1994 <main+0x192>
    if (read8(BME280_REGISTER_CHIPID) != 0x60)
        return false;

    // reset the device using soft-reset
    // this makes sure the IIR is off, etc.
    write8(BME280_REGISTER_SOFTRESET, 0xB6);
    1a48:	66 eb       	ldi	r22, 0xB6	; 182
    1a4a:	80 ee       	ldi	r24, 0xE0	; 224
    1a4c:	0e 94 37 04 	call	0x86e	; 0x86e <_ZN15Adafruit_BME2806write8Ehh.constprop.40>

    // wait for chip to wake up.
    delay(300);
    1a50:	6c e2       	ldi	r22, 0x2C	; 44
    1a52:	71 e0       	ldi	r23, 0x01	; 1
    1a54:	80 e0       	ldi	r24, 0x00	; 0
    1a56:	90 e0       	ldi	r25, 0x00	; 0
    1a58:	0e 94 ef 02 	call	0x5de	; 0x5de <delay>
    @returns true if reading calibration, false otherwise
*/
/**************************************************************************/
bool Adafruit_BME280::isReadingCalibration(void)
{
  uint8_t const rStatus = read8(BME280_REGISTER_STATUS);
    1a5c:	83 ef       	ldi	r24, 0xF3	; 243
    1a5e:	0e 94 09 06 	call	0xc12	; 0xc12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>

    // wait for chip to wake up.
    delay(300);

    // if chip is still reading calibration, delay
    while (isReadingCalibration())
    1a62:	80 ff       	sbrs	r24, 0
    1a64:	05 c0       	rjmp	.+10     	; 0x1a70 <main+0x26e>
          delay(100);
    1a66:	64 e6       	ldi	r22, 0x64	; 100
    1a68:	70 e0       	ldi	r23, 0x00	; 0
    1a6a:	80 e0       	ldi	r24, 0x00	; 0
    1a6c:	90 e0       	ldi	r25, 0x00	; 0
    1a6e:	f4 cf       	rjmp	.-24     	; 0x1a58 <main+0x256>
    @brief  Reads the factory-set coefficients
*/
/**************************************************************************/
void Adafruit_BME280::readCoefficients(void)
{
    _bme280_calib.dig_T1 = read16_LE(BME280_REGISTER_DIG_T1);
    1a70:	88 e8       	ldi	r24, 0x88	; 136
    1a72:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    1a76:	90 93 3f 03 	sts	0x033F, r25	; 0x80033f <bme+0x10>
    1a7a:	80 93 3e 03 	sts	0x033E, r24	; 0x80033e <bme+0xf>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1a7e:	8a e8       	ldi	r24, 0x8A	; 138
    1a80:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
*/
/**************************************************************************/
void Adafruit_BME280::readCoefficients(void)
{
    _bme280_calib.dig_T1 = read16_LE(BME280_REGISTER_DIG_T1);
    _bme280_calib.dig_T2 = readS16_LE(BME280_REGISTER_DIG_T2);
    1a84:	90 93 41 03 	sts	0x0341, r25	; 0x800341 <bme+0x12>
    1a88:	80 93 40 03 	sts	0x0340, r24	; 0x800340 <bme+0x11>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1a8c:	8c e8       	ldi	r24, 0x8C	; 140
    1a8e:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
/**************************************************************************/
void Adafruit_BME280::readCoefficients(void)
{
    _bme280_calib.dig_T1 = read16_LE(BME280_REGISTER_DIG_T1);
    _bme280_calib.dig_T2 = readS16_LE(BME280_REGISTER_DIG_T2);
    _bme280_calib.dig_T3 = readS16_LE(BME280_REGISTER_DIG_T3);
    1a92:	90 93 43 03 	sts	0x0343, r25	; 0x800343 <bme+0x14>
    1a96:	80 93 42 03 	sts	0x0342, r24	; 0x800342 <bme+0x13>

    _bme280_calib.dig_P1 = read16_LE(BME280_REGISTER_DIG_P1);
    1a9a:	8e e8       	ldi	r24, 0x8E	; 142
    1a9c:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    1aa0:	90 93 45 03 	sts	0x0345, r25	; 0x800345 <bme+0x16>
    1aa4:	80 93 44 03 	sts	0x0344, r24	; 0x800344 <bme+0x15>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1aa8:	80 e9       	ldi	r24, 0x90	; 144
    1aaa:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    _bme280_calib.dig_T1 = read16_LE(BME280_REGISTER_DIG_T1);
    _bme280_calib.dig_T2 = readS16_LE(BME280_REGISTER_DIG_T2);
    _bme280_calib.dig_T3 = readS16_LE(BME280_REGISTER_DIG_T3);

    _bme280_calib.dig_P1 = read16_LE(BME280_REGISTER_DIG_P1);
    _bme280_calib.dig_P2 = readS16_LE(BME280_REGISTER_DIG_P2);
    1aae:	90 93 47 03 	sts	0x0347, r25	; 0x800347 <bme+0x18>
    1ab2:	80 93 46 03 	sts	0x0346, r24	; 0x800346 <bme+0x17>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1ab6:	82 e9       	ldi	r24, 0x92	; 146
    1ab8:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    _bme280_calib.dig_T2 = readS16_LE(BME280_REGISTER_DIG_T2);
    _bme280_calib.dig_T3 = readS16_LE(BME280_REGISTER_DIG_T3);

    _bme280_calib.dig_P1 = read16_LE(BME280_REGISTER_DIG_P1);
    _bme280_calib.dig_P2 = readS16_LE(BME280_REGISTER_DIG_P2);
    _bme280_calib.dig_P3 = readS16_LE(BME280_REGISTER_DIG_P3);
    1abc:	90 93 49 03 	sts	0x0349, r25	; 0x800349 <bme+0x1a>
    1ac0:	80 93 48 03 	sts	0x0348, r24	; 0x800348 <bme+0x19>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1ac4:	84 e9       	ldi	r24, 0x94	; 148
    1ac6:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    _bme280_calib.dig_T3 = readS16_LE(BME280_REGISTER_DIG_T3);

    _bme280_calib.dig_P1 = read16_LE(BME280_REGISTER_DIG_P1);
    _bme280_calib.dig_P2 = readS16_LE(BME280_REGISTER_DIG_P2);
    _bme280_calib.dig_P3 = readS16_LE(BME280_REGISTER_DIG_P3);
    _bme280_calib.dig_P4 = readS16_LE(BME280_REGISTER_DIG_P4);
    1aca:	90 93 4b 03 	sts	0x034B, r25	; 0x80034b <bme+0x1c>
    1ace:	80 93 4a 03 	sts	0x034A, r24	; 0x80034a <bme+0x1b>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1ad2:	86 e9       	ldi	r24, 0x96	; 150
    1ad4:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>

    _bme280_calib.dig_P1 = read16_LE(BME280_REGISTER_DIG_P1);
    _bme280_calib.dig_P2 = readS16_LE(BME280_REGISTER_DIG_P2);
    _bme280_calib.dig_P3 = readS16_LE(BME280_REGISTER_DIG_P3);
    _bme280_calib.dig_P4 = readS16_LE(BME280_REGISTER_DIG_P4);
    _bme280_calib.dig_P5 = readS16_LE(BME280_REGISTER_DIG_P5);
    1ad8:	90 93 4d 03 	sts	0x034D, r25	; 0x80034d <bme+0x1e>
    1adc:	80 93 4c 03 	sts	0x034C, r24	; 0x80034c <bme+0x1d>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1ae0:	88 e9       	ldi	r24, 0x98	; 152
    1ae2:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    _bme280_calib.dig_P1 = read16_LE(BME280_REGISTER_DIG_P1);
    _bme280_calib.dig_P2 = readS16_LE(BME280_REGISTER_DIG_P2);
    _bme280_calib.dig_P3 = readS16_LE(BME280_REGISTER_DIG_P3);
    _bme280_calib.dig_P4 = readS16_LE(BME280_REGISTER_DIG_P4);
    _bme280_calib.dig_P5 = readS16_LE(BME280_REGISTER_DIG_P5);
    _bme280_calib.dig_P6 = readS16_LE(BME280_REGISTER_DIG_P6);
    1ae6:	90 93 4f 03 	sts	0x034F, r25	; 0x80034f <bme+0x20>
    1aea:	80 93 4e 03 	sts	0x034E, r24	; 0x80034e <bme+0x1f>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1aee:	8a e9       	ldi	r24, 0x9A	; 154
    1af0:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    _bme280_calib.dig_P2 = readS16_LE(BME280_REGISTER_DIG_P2);
    _bme280_calib.dig_P3 = readS16_LE(BME280_REGISTER_DIG_P3);
    _bme280_calib.dig_P4 = readS16_LE(BME280_REGISTER_DIG_P4);
    _bme280_calib.dig_P5 = readS16_LE(BME280_REGISTER_DIG_P5);
    _bme280_calib.dig_P6 = readS16_LE(BME280_REGISTER_DIG_P6);
    _bme280_calib.dig_P7 = readS16_LE(BME280_REGISTER_DIG_P7);
    1af4:	90 93 51 03 	sts	0x0351, r25	; 0x800351 <bme+0x22>
    1af8:	80 93 50 03 	sts	0x0350, r24	; 0x800350 <bme+0x21>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1afc:	8c e9       	ldi	r24, 0x9C	; 156
    1afe:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    _bme280_calib.dig_P3 = readS16_LE(BME280_REGISTER_DIG_P3);
    _bme280_calib.dig_P4 = readS16_LE(BME280_REGISTER_DIG_P4);
    _bme280_calib.dig_P5 = readS16_LE(BME280_REGISTER_DIG_P5);
    _bme280_calib.dig_P6 = readS16_LE(BME280_REGISTER_DIG_P6);
    _bme280_calib.dig_P7 = readS16_LE(BME280_REGISTER_DIG_P7);
    _bme280_calib.dig_P8 = readS16_LE(BME280_REGISTER_DIG_P8);
    1b02:	90 93 53 03 	sts	0x0353, r25	; 0x800353 <bme+0x24>
    1b06:	80 93 52 03 	sts	0x0352, r24	; 0x800352 <bme+0x23>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1b0a:	8e e9       	ldi	r24, 0x9E	; 158
    1b0c:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    _bme280_calib.dig_P4 = readS16_LE(BME280_REGISTER_DIG_P4);
    _bme280_calib.dig_P5 = readS16_LE(BME280_REGISTER_DIG_P5);
    _bme280_calib.dig_P6 = readS16_LE(BME280_REGISTER_DIG_P6);
    _bme280_calib.dig_P7 = readS16_LE(BME280_REGISTER_DIG_P7);
    _bme280_calib.dig_P8 = readS16_LE(BME280_REGISTER_DIG_P8);
    _bme280_calib.dig_P9 = readS16_LE(BME280_REGISTER_DIG_P9);
    1b10:	90 93 55 03 	sts	0x0355, r25	; 0x800355 <bme+0x26>
    1b14:	80 93 54 03 	sts	0x0354, r24	; 0x800354 <bme+0x25>

    _bme280_calib.dig_H1 = read8(BME280_REGISTER_DIG_H1);
    1b18:	81 ea       	ldi	r24, 0xA1	; 161
    1b1a:	0e 94 09 06 	call	0xc12	; 0xc12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>
    1b1e:	80 93 56 03 	sts	0x0356, r24	; 0x800356 <bme+0x27>
    @returns the 16 bit data value read from the device
*/
/**************************************************************************/
int16_t Adafruit_BME280::readS16_LE(byte reg)
{
    return (int16_t)read16_LE(reg);
    1b22:	81 ee       	ldi	r24, 0xE1	; 225
    1b24:	0e 94 cb 06 	call	0xd96	; 0xd96 <_ZN15Adafruit_BME2809read16_LEEh.constprop.31>
    _bme280_calib.dig_P7 = readS16_LE(BME280_REGISTER_DIG_P7);
    _bme280_calib.dig_P8 = readS16_LE(BME280_REGISTER_DIG_P8);
    _bme280_calib.dig_P9 = readS16_LE(BME280_REGISTER_DIG_P9);

    _bme280_calib.dig_H1 = read8(BME280_REGISTER_DIG_H1);
    _bme280_calib.dig_H2 = readS16_LE(BME280_REGISTER_DIG_H2);
    1b28:	90 93 58 03 	sts	0x0358, r25	; 0x800358 <bme+0x29>
    1b2c:	80 93 57 03 	sts	0x0357, r24	; 0x800357 <bme+0x28>
    _bme280_calib.dig_H3 = read8(BME280_REGISTER_DIG_H3);
    1b30:	83 ee       	ldi	r24, 0xE3	; 227
    1b32:	0e 94 09 06 	call	0xc12	; 0xc12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>
    1b36:	80 93 59 03 	sts	0x0359, r24	; 0x800359 <bme+0x2a>
    _bme280_calib.dig_H4 = (read8(BME280_REGISTER_DIG_H4) << 4) | (read8(BME280_REGISTER_DIG_H4+1) & 0xF);
    1b3a:	84 ee       	ldi	r24, 0xE4	; 228
    1b3c:	0e 94 09 06 	call	0xc12	; 0xc12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>
    1b40:	c8 2f       	mov	r28, r24
    1b42:	85 ee       	ldi	r24, 0xE5	; 229
    1b44:	0e 94 09 06 	call	0xc12	; 0xc12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>
    1b48:	f0 e1       	ldi	r31, 0x10	; 16
    1b4a:	cf 9f       	mul	r28, r31
    1b4c:	90 01       	movw	r18, r0
    1b4e:	11 24       	eor	r1, r1
    1b50:	8f 70       	andi	r24, 0x0F	; 15
    1b52:	28 2b       	or	r18, r24
    1b54:	30 93 5b 03 	sts	0x035B, r19	; 0x80035b <bme+0x2c>
    1b58:	20 93 5a 03 	sts	0x035A, r18	; 0x80035a <bme+0x2b>
    _bme280_calib.dig_H5 = (read8(BME280_REGISTER_DIG_H5+1) << 4) | (read8(BME280_REGISTER_DIG_H5) >> 4);
    1b5c:	86 ee       	ldi	r24, 0xE6	; 230
    1b5e:	0e 94 09 06 	call	0xc12	; 0xc12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>
    1b62:	c8 2f       	mov	r28, r24
    1b64:	85 ee       	ldi	r24, 0xE5	; 229
    1b66:	0e 94 09 06 	call	0xc12	; 0xc12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>
    1b6a:	20 e1       	ldi	r18, 0x10	; 16
    1b6c:	c2 9f       	mul	r28, r18
    1b6e:	e0 01       	movw	r28, r0
    1b70:	11 24       	eor	r1, r1
    1b72:	90 e0       	ldi	r25, 0x00	; 0
    1b74:	34 e0       	ldi	r19, 0x04	; 4
    1b76:	95 95       	asr	r25
    1b78:	87 95       	ror	r24
    1b7a:	3a 95       	dec	r19
    1b7c:	e1 f7       	brne	.-8      	; 0x1b76 <main+0x374>
    1b7e:	8c 2b       	or	r24, r28
    1b80:	9d 2b       	or	r25, r29
    1b82:	90 93 5d 03 	sts	0x035D, r25	; 0x80035d <bme+0x2e>
    1b86:	80 93 5c 03 	sts	0x035C, r24	; 0x80035c <bme+0x2d>
    _bme280_calib.dig_H6 = (int8_t)read8(BME280_REGISTER_DIG_H6);
    1b8a:	87 ee       	ldi	r24, 0xE7	; 231
    1b8c:	0e 94 09 06 	call	0xc12	; 0xc12 <_ZN15Adafruit_BME2805read8Eh.constprop.34>
    1b90:	80 93 5e 03 	sts	0x035E, r24	; 0x80035e <bme+0x2f>
		 sensor_sampling   pressSampling,
		 sensor_sampling   humSampling,
		 sensor_filter     filter,
		 standby_duration  duration) {
    _measReg.mode     = mode;
    _measReg.osrs_t   = tempSampling;
    1b94:	8d ee       	ldi	r24, 0xED	; 237
    1b96:	80 93 60 03 	sts	0x0360, r24	; 0x800360 <bme+0x31>
    _measReg.osrs_p   = pressSampling;
        
    
    _humReg.osrs_h    = humSampling;
    1b9a:	80 91 61 03 	lds	r24, 0x0361	; 0x800361 <bme+0x32>
    1b9e:	8f 71       	andi	r24, 0x1F	; 31
    1ba0:	80 6a       	ori	r24, 0xA0	; 160
    1ba2:	80 93 61 03 	sts	0x0361, r24	; 0x800361 <bme+0x32>
    _configReg.filter = filter;
    1ba6:	80 91 5f 03 	lds	r24, 0x035F	; 0x80035f <bme+0x30>
    _configReg.t_sb   = duration;
    1baa:	80 7c       	andi	r24, 0xC0	; 192
    1bac:	80 93 5f 03 	sts	0x035F, r24	; 0x80035f <bme+0x30>

    
    // you must make sure to also set REGISTER_CONTROL after setting the
    // CONTROLHUMID register, otherwise the values won't be applied (see DS 5.4.3)
    write8(BME280_REGISTER_CONTROLHUMID, _humReg.get());
    1bb0:	65 e0       	ldi	r22, 0x05	; 5
    1bb2:	82 ef       	ldi	r24, 0xF2	; 242
    1bb4:	0e 94 37 04 	call	0x86e	; 0x86e <_ZN15Adafruit_BME2806write8Ehh.constprop.40>
            // unused - don't set
            unsigned int none : 1;
            unsigned int spi3w_en : 1;

            unsigned int get() {
                return (t_sb << 5) | (filter << 3) | spi3w_en;
    1bb8:	80 91 5f 03 	lds	r24, 0x035F	; 0x80035f <bme+0x30>
    1bbc:	68 2f       	mov	r22, r24
    1bbe:	67 70       	andi	r22, 0x07	; 7
    1bc0:	90 e2       	ldi	r25, 0x20	; 32
    1bc2:	69 9f       	mul	r22, r25
    1bc4:	b0 01       	movw	r22, r0
    1bc6:	11 24       	eor	r1, r1
    1bc8:	28 2f       	mov	r18, r24
    1bca:	26 95       	lsr	r18
    1bcc:	26 95       	lsr	r18
    1bce:	26 95       	lsr	r18
    1bd0:	27 70       	andi	r18, 0x07	; 7
    1bd2:	e8 e0       	ldi	r30, 0x08	; 8
    1bd4:	2e 9f       	mul	r18, r30
    1bd6:	90 01       	movw	r18, r0
    1bd8:	11 24       	eor	r1, r1
    1bda:	62 2b       	or	r22, r18
    1bdc:	87 fb       	bst	r24, 7
    1bde:	88 27       	eor	r24, r24
    1be0:	80 f9       	bld	r24, 0
    1be2:	68 2b       	or	r22, r24
    write8(BME280_REGISTER_CONFIG, _configReg.get());
    1be4:	85 ef       	ldi	r24, 0xF5	; 245
    1be6:	0e 94 37 04 	call	0x86e	; 0x86e <_ZN15Adafruit_BME2806write8Ehh.constprop.40>
            // 01 or 10 = forced
            // 11       = normal
            unsigned int mode : 2;

            unsigned int get() {
                return (osrs_t << 5) | (osrs_p << 3) | mode;
    1bea:	80 91 60 03 	lds	r24, 0x0360	; 0x800360 <bme+0x31>
    1bee:	68 2f       	mov	r22, r24
    1bf0:	67 70       	andi	r22, 0x07	; 7
    1bf2:	f0 e2       	ldi	r31, 0x20	; 32
    1bf4:	6f 9f       	mul	r22, r31
    1bf6:	b0 01       	movw	r22, r0
    1bf8:	11 24       	eor	r1, r1
    1bfa:	28 2f       	mov	r18, r24
    1bfc:	26 95       	lsr	r18
    1bfe:	26 95       	lsr	r18
    1c00:	26 95       	lsr	r18
    1c02:	27 70       	andi	r18, 0x07	; 7
    1c04:	98 e0       	ldi	r25, 0x08	; 8
    1c06:	29 9f       	mul	r18, r25
    1c08:	90 01       	movw	r18, r0
    1c0a:	11 24       	eor	r1, r1
    1c0c:	62 2b       	or	r22, r18
    1c0e:	82 95       	swap	r24
    1c10:	86 95       	lsr	r24
    1c12:	86 95       	lsr	r24
    1c14:	83 70       	andi	r24, 0x03	; 3
    1c16:	68 2b       	or	r22, r24
    write8(BME280_REGISTER_CONTROL, _measReg.get());
    1c18:	84 ef       	ldi	r24, 0xF4	; 244
    1c1a:	0e 94 37 04 	call	0x86e	; 0x86e <_ZN15Adafruit_BME2806write8Ehh.constprop.40>

    readCoefficients(); // read trimming parameters, see DS 4.2.2

    setSampling(); // use defaults

    delay(100);
    1c1e:	64 e6       	ldi	r22, 0x64	; 100
    1c20:	70 e0       	ldi	r23, 0x00	; 0
    1c22:	80 e0       	ldi	r24, 0x00	; 0
    1c24:	90 e0       	ldi	r25, 0x00	; 0
    1c26:	0e 94 ef 02 	call	0x5de	; 0x5de <delay>
        while (1);
    }
    
    Serial.println("-- Default Test --");
    1c2a:	87 e6       	ldi	r24, 0x67	; 103
    1c2c:	91 e0       	ldi	r25, 0x01	; 1
    1c2e:	0e 94 d9 04 	call	0x9b2	; 0x9b2 <_ZN5Print7printlnEPKc.constprop.49>
    delayTime = 1000;
    1c32:	88 ee       	ldi	r24, 0xE8	; 232
    1c34:	93 e0       	ldi	r25, 0x03	; 3
    1c36:	a0 e0       	ldi	r26, 0x00	; 0
    1c38:	b0 e0       	ldi	r27, 0x00	; 0
    1c3a:	80 93 7e 02 	sts	0x027E, r24	; 0x80027e <delayTime>
    1c3e:	90 93 7f 02 	sts	0x027F, r25	; 0x80027f <delayTime+0x1>
    1c42:	a0 93 80 02 	sts	0x0280, r26	; 0x800280 <delayTime+0x2>
    1c46:	b0 93 81 02 	sts	0x0281, r27	; 0x800281 <delayTime+0x3>
    1c4a:	84 e2       	ldi	r24, 0x24	; 36
    1c4c:	91 e0       	ldi	r25, 0x01	; 1
    1c4e:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>
#endif

void serialEventRun(void)
{
#if defined(HAVE_HWSERIAL0)
  if (Serial0_available && serialEvent && Serial0_available()) serialEvent();
    1c52:	c0 e0       	ldi	r28, 0x00	; 0
    1c54:	d0 e0       	ldi	r29, 0x00	; 0
    1c56:	8a e7       	ldi	r24, 0x7A	; 122
    1c58:	91 e0       	ldi	r25, 0x01	; 1
    1c5a:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>
}


void printValues() {
    Serial.print("Temperature = ");
    Serial.print(bme.readTemperature());
    1c5e:	0e 94 7b 07 	call	0xef6	; 0xef6 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9>
  else return printNumber(n, base);
}

size_t Print::print(double n, int digits)
{
  return printFloat(n, digits);
    1c62:	42 e0       	ldi	r20, 0x02	; 2
    1c64:	0e 94 e7 04 	call	0x9ce	; 0x9ce <_ZN5Print10printFloatEdh.constprop.12>
    Serial.println(" *C");
    1c68:	89 e8       	ldi	r24, 0x89	; 137
    1c6a:	91 e0       	ldi	r25, 0x01	; 1
    1c6c:	0e 94 d9 04 	call	0x9b2	; 0x9b2 <_ZN5Print7printlnEPKc.constprop.49>
    1c70:	8d e8       	ldi	r24, 0x8D	; 141
    1c72:	91 e0       	ldi	r25, 0x01	; 1
    1c74:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>

    Serial.print("Pressure = ");

    Serial.print(bme.readPressure() / 100.0F);
    1c78:	0e 94 11 08 	call	0x1022	; 0x1022 <_ZN15Adafruit_BME28012readPressureEv.constprop.6>
    1c7c:	20 e0       	ldi	r18, 0x00	; 0
    1c7e:	30 e0       	ldi	r19, 0x00	; 0
    1c80:	48 ec       	ldi	r20, 0xC8	; 200
    1c82:	52 e4       	ldi	r21, 0x42	; 66
    1c84:	0e 94 ec 0f 	call	0x1fd8	; 0x1fd8 <__divsf3>
    1c88:	42 e0       	ldi	r20, 0x02	; 2
    1c8a:	0e 94 e7 04 	call	0x9ce	; 0x9ce <_ZN5Print10printFloatEdh.constprop.12>
    Serial.println(" hPa");
    1c8e:	89 e9       	ldi	r24, 0x99	; 153
    1c90:	91 e0       	ldi	r25, 0x01	; 1
    1c92:	0e 94 d9 04 	call	0x9b2	; 0x9b2 <_ZN5Print7printlnEPKc.constprop.49>
    1c96:	8e e9       	ldi	r24, 0x9E	; 158
    1c98:	91 e0       	ldi	r25, 0x01	; 1
    1c9a:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>

    // Note that using the equation from wikipedia can give bad results
    // at high altitude. See this thread for more information:
    //  http://forums.adafruit.com/viewtopic.php?f=22&t=58064

    float atmospheric = readPressure() / 100.0F;
    1c9e:	0e 94 11 08 	call	0x1022	; 0x1022 <_ZN15Adafruit_BME28012readPressureEv.constprop.6>
    1ca2:	20 e0       	ldi	r18, 0x00	; 0
    1ca4:	30 e0       	ldi	r19, 0x00	; 0
    1ca6:	48 ec       	ldi	r20, 0xC8	; 200
    1ca8:	52 e4       	ldi	r21, 0x42	; 66
    1caa:	0e 94 ec 0f 	call	0x1fd8	; 0x1fd8 <__divsf3>
    return 44330.0 * (1.0 - pow(atmospheric / seaLevel, 0.1903));
    1cae:	20 e0       	ldi	r18, 0x00	; 0
    1cb0:	30 e5       	ldi	r19, 0x50	; 80
    1cb2:	4d e7       	ldi	r20, 0x7D	; 125
    1cb4:	54 e4       	ldi	r21, 0x44	; 68
    1cb6:	0e 94 ec 0f 	call	0x1fd8	; 0x1fd8 <__divsf3>
    1cba:	21 e0       	ldi	r18, 0x01	; 1
    1cbc:	3e ed       	ldi	r19, 0xDE	; 222
    1cbe:	42 e4       	ldi	r20, 0x42	; 66
    1cc0:	5e e3       	ldi	r21, 0x3E	; 62
    1cc2:	0e 94 05 12 	call	0x240a	; 0x240a <pow>
    1cc6:	9b 01       	movw	r18, r22
    1cc8:	ac 01       	movw	r20, r24
    1cca:	60 e0       	ldi	r22, 0x00	; 0
    1ccc:	70 e0       	ldi	r23, 0x00	; 0
    1cce:	80 e8       	ldi	r24, 0x80	; 128
    1cd0:	9f e3       	ldi	r25, 0x3F	; 63
    1cd2:	0e 94 7a 0f 	call	0x1ef4	; 0x1ef4 <__subsf3>
    1cd6:	20 e0       	ldi	r18, 0x00	; 0
    1cd8:	3a e2       	ldi	r19, 0x2A	; 42
    1cda:	4d e2       	ldi	r20, 0x2D	; 45
    1cdc:	57 e4       	ldi	r21, 0x47	; 71
    1cde:	0e 94 98 11 	call	0x2330	; 0x2330 <__mulsf3>
    1ce2:	42 e0       	ldi	r20, 0x02	; 2
    1ce4:	0e 94 e7 04 	call	0x9ce	; 0x9ce <_ZN5Print10printFloatEdh.constprop.12>

    Serial.print("Approx. Altitude = ");
    Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
    Serial.println(" m");
    1ce8:	82 eb       	ldi	r24, 0xB2	; 178
    1cea:	91 e0       	ldi	r25, 0x01	; 1
    1cec:	0e 94 d9 04 	call	0x9b2	; 0x9b2 <_ZN5Print7printlnEPKc.constprop.49>
    1cf0:	85 eb       	ldi	r24, 0xB5	; 181
    1cf2:	91 e0       	ldi	r25, 0x01	; 1
    1cf4:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>
    @brief  Returns the humidity from the sensor
    @returns the humidity value read from the device
*/
/**************************************************************************/
float Adafruit_BME280::readHumidity(void) {
    readTemperature(); // must be done first to get t_fine
    1cf8:	0e 94 7b 07 	call	0xef6	; 0xef6 <_ZN15Adafruit_BME28015readTemperatureEv.constprop.9>

    int32_t adc_H = read16(BME280_REGISTER_HUMIDDATA);
    1cfc:	8d ef       	ldi	r24, 0xFD	; 253
    1cfe:	0e 94 5e 06 	call	0xcbc	; 0xcbc <_ZN15Adafruit_BME2806read16Eh.constprop.32>
    1d02:	b0 e0       	ldi	r27, 0x00	; 0
    1d04:	a0 e0       	ldi	r26, 0x00	; 0
    if (adc_H == 0x8000) // value in case humidity measurement was disabled
    1d06:	81 15       	cp	r24, r1
    1d08:	e0 e8       	ldi	r30, 0x80	; 128
    1d0a:	9e 07       	cpc	r25, r30
    1d0c:	a1 05       	cpc	r26, r1
    1d0e:	b1 05       	cpc	r27, r1
    1d10:	09 f4       	brne	.+2      	; 0x1d14 <main+0x512>
    1d12:	eb c0       	rjmp	.+470    	; 0x1eea <main+0x6e8>
        return NAN;
        
    int32_t v_x1_u32r;

    v_x1_u32r = (t_fine - ((int32_t)76800));
    1d14:	80 90 36 03 	lds	r8, 0x0336	; 0x800336 <bme+0x7>
    1d18:	90 90 37 03 	lds	r9, 0x0337	; 0x800337 <bme+0x8>
    1d1c:	a0 90 38 03 	lds	r10, 0x0338	; 0x800338 <bme+0x9>
    1d20:	b0 90 39 03 	lds	r11, 0x0339	; 0x800339 <bme+0xa>
    1d24:	fc e2       	ldi	r31, 0x2C	; 44
    1d26:	9f 1a       	sub	r9, r31
    1d28:	f1 e0       	ldi	r31, 0x01	; 1
    1d2a:	af 0a       	sbc	r10, r31
    1d2c:	b1 08       	sbc	r11, r1

    v_x1_u32r = (((((adc_H << 14) - (((int32_t)_bme280_calib.dig_H4) << 20) -
    1d2e:	6c 01       	movw	r12, r24
    1d30:	7d 01       	movw	r14, r26
    1d32:	3e e0       	ldi	r19, 0x0E	; 14
    1d34:	cc 0c       	add	r12, r12
    1d36:	dd 1c       	adc	r13, r13
    1d38:	ee 1c       	adc	r14, r14
    1d3a:	ff 1c       	adc	r15, r15
    1d3c:	3a 95       	dec	r19
    1d3e:	d1 f7       	brne	.-12     	; 0x1d34 <main+0x532>
    1d40:	80 91 5a 03 	lds	r24, 0x035A	; 0x80035a <bme+0x2b>
    1d44:	90 91 5b 03 	lds	r25, 0x035B	; 0x80035b <bme+0x2c>
    1d48:	09 2e       	mov	r0, r25
    1d4a:	00 0c       	add	r0, r0
    1d4c:	aa 0b       	sbc	r26, r26
    1d4e:	bb 0b       	sbc	r27, r27
    1d50:	44 e1       	ldi	r20, 0x14	; 20
    1d52:	88 0f       	add	r24, r24
    1d54:	99 1f       	adc	r25, r25
    1d56:	aa 1f       	adc	r26, r26
    1d58:	bb 1f       	adc	r27, r27
    1d5a:	4a 95       	dec	r20
    1d5c:	d1 f7       	brne	.-12     	; 0x1d52 <main+0x550>
    1d5e:	c8 1a       	sub	r12, r24
    1d60:	d9 0a       	sbc	r13, r25
    1d62:	ea 0a       	sbc	r14, r26
    1d64:	fb 0a       	sbc	r15, r27
                    (((int32_t)_bme280_calib.dig_H5) * v_x1_u32r)) + ((int32_t)16384)) >> 15) *
    1d66:	a0 91 5c 03 	lds	r26, 0x035C	; 0x80035c <bme+0x2d>
    1d6a:	b0 91 5d 03 	lds	r27, 0x035D	; 0x80035d <bme+0x2e>
    1d6e:	a5 01       	movw	r20, r10
    1d70:	94 01       	movw	r18, r8
    1d72:	0e 94 cc 13 	call	0x2798	; 0x2798 <__mulshisi3>
        
    int32_t v_x1_u32r;

    v_x1_u32r = (t_fine - ((int32_t)76800));

    v_x1_u32r = (((((adc_H << 14) - (((int32_t)_bme280_calib.dig_H4) << 20) -
    1d76:	c6 1a       	sub	r12, r22
    1d78:	d7 0a       	sbc	r13, r23
    1d7a:	e8 0a       	sbc	r14, r24
    1d7c:	f9 0a       	sbc	r15, r25
                    (((int32_t)_bme280_calib.dig_H5) * v_x1_u32r)) + ((int32_t)16384)) >> 15) *
    1d7e:	20 e4       	ldi	r18, 0x40	; 64
    1d80:	d2 0e       	add	r13, r18
    1d82:	e1 1c       	adc	r14, r1
    1d84:	f1 1c       	adc	r15, r1
    1d86:	5f e0       	ldi	r21, 0x0F	; 15
    1d88:	f5 94       	asr	r15
    1d8a:	e7 94       	ror	r14
    1d8c:	d7 94       	ror	r13
    1d8e:	c7 94       	ror	r12
    1d90:	5a 95       	dec	r21
    1d92:	d1 f7       	brne	.-12     	; 0x1d88 <main+0x586>
                 (((((((v_x1_u32r * ((int32_t)_bme280_calib.dig_H6)) >> 10) *
                      (((v_x1_u32r * ((int32_t)_bme280_calib.dig_H3)) >> 11) + ((int32_t)32768))) >> 10) +
    1d94:	a0 91 59 03 	lds	r26, 0x0359	; 0x800359 <bme+0x2a>
    1d98:	b0 e0       	ldi	r27, 0x00	; 0
    1d9a:	a5 01       	movw	r20, r10
    1d9c:	94 01       	movw	r18, r8
    1d9e:	0e 94 c1 13 	call	0x2782	; 0x2782 <__muluhisi3>
    1da2:	2b 01       	movw	r4, r22
    1da4:	3c 01       	movw	r6, r24
    1da6:	6b e0       	ldi	r22, 0x0B	; 11
    1da8:	75 94       	asr	r7
    1daa:	67 94       	ror	r6
    1dac:	57 94       	ror	r5
    1dae:	47 94       	ror	r4
    1db0:	6a 95       	dec	r22
    1db2:	d1 f7       	brne	.-12     	; 0x1da8 <main+0x5a6>
    1db4:	80 e8       	ldi	r24, 0x80	; 128
    1db6:	58 0e       	add	r5, r24
    1db8:	61 1c       	adc	r6, r1
    1dba:	71 1c       	adc	r7, r1

    v_x1_u32r = (t_fine - ((int32_t)76800));

    v_x1_u32r = (((((adc_H << 14) - (((int32_t)_bme280_calib.dig_H4) << 20) -
                    (((int32_t)_bme280_calib.dig_H5) * v_x1_u32r)) + ((int32_t)16384)) >> 15) *
                 (((((((v_x1_u32r * ((int32_t)_bme280_calib.dig_H6)) >> 10) *
    1dbc:	a0 91 5e 03 	lds	r26, 0x035E	; 0x80035e <bme+0x2f>
    1dc0:	0a 2e       	mov	r0, r26
    1dc2:	00 0c       	add	r0, r0
    1dc4:	bb 0b       	sbc	r27, r27
    1dc6:	0e 94 cc 13 	call	0x2798	; 0x2798 <__mulshisi3>
    1dca:	ea e0       	ldi	r30, 0x0A	; 10
    1dcc:	95 95       	asr	r25
    1dce:	87 95       	ror	r24
    1dd0:	77 95       	ror	r23
    1dd2:	67 95       	ror	r22
    1dd4:	ea 95       	dec	r30
    1dd6:	d1 f7       	brne	.-12     	; 0x1dcc <main+0x5ca>
    1dd8:	a3 01       	movw	r20, r6
    1dda:	92 01       	movw	r18, r4
    1ddc:	0e 94 8f 13 	call	0x271e	; 0x271e <__mulsi3>
                      (((v_x1_u32r * ((int32_t)_bme280_calib.dig_H3)) >> 11) + ((int32_t)32768))) >> 10) +
    1de0:	9b 01       	movw	r18, r22
    1de2:	ac 01       	movw	r20, r24
    1de4:	fa e0       	ldi	r31, 0x0A	; 10
    1de6:	55 95       	asr	r21
    1de8:	47 95       	ror	r20
    1dea:	37 95       	ror	r19
    1dec:	27 95       	ror	r18
    1dee:	fa 95       	dec	r31
    1df0:	d1 f7       	brne	.-12     	; 0x1de6 <main+0x5e4>
    1df2:	40 5e       	subi	r20, 0xE0	; 224
    1df4:	5f 4f       	sbci	r21, 0xFF	; 255
                    ((int32_t)2097152)) * ((int32_t)_bme280_calib.dig_H2) + 8192) >> 14));
    1df6:	a0 91 57 03 	lds	r26, 0x0357	; 0x800357 <bme+0x28>
    1dfa:	b0 91 58 03 	lds	r27, 0x0358	; 0x800358 <bme+0x29>
    1dfe:	0e 94 cc 13 	call	0x2798	; 0x2798 <__mulshisi3>
    1e02:	70 5e       	subi	r23, 0xE0	; 224
    1e04:	8f 4f       	sbci	r24, 0xFF	; 255
    1e06:	9f 4f       	sbci	r25, 0xFF	; 255
    1e08:	ae e0       	ldi	r26, 0x0E	; 14
    1e0a:	95 95       	asr	r25
    1e0c:	87 95       	ror	r24
    1e0e:	77 95       	ror	r23
    1e10:	67 95       	ror	r22
    1e12:	aa 95       	dec	r26
    1e14:	d1 f7       	brne	.-12     	; 0x1e0a <main+0x608>
        
    int32_t v_x1_u32r;

    v_x1_u32r = (t_fine - ((int32_t)76800));

    v_x1_u32r = (((((adc_H << 14) - (((int32_t)_bme280_calib.dig_H4) << 20) -
    1e16:	a7 01       	movw	r20, r14
    1e18:	96 01       	movw	r18, r12
    1e1a:	0e 94 8f 13 	call	0x271e	; 0x271e <__mulsi3>
    1e1e:	6b 01       	movw	r12, r22
    1e20:	7c 01       	movw	r14, r24
                    (((int32_t)_bme280_calib.dig_H5) * v_x1_u32r)) + ((int32_t)16384)) >> 15) *
                 (((((((v_x1_u32r * ((int32_t)_bme280_calib.dig_H6)) >> 10) *
                      (((v_x1_u32r * ((int32_t)_bme280_calib.dig_H3)) >> 11) + ((int32_t)32768))) >> 10) +
                    ((int32_t)2097152)) * ((int32_t)_bme280_calib.dig_H2) + 8192) >> 14));

    v_x1_u32r = (v_x1_u32r - (((((v_x1_u32r >> 15) * (v_x1_u32r >> 15)) >> 7) *
    1e22:	bf e0       	ldi	r27, 0x0F	; 15
    1e24:	95 95       	asr	r25
    1e26:	87 95       	ror	r24
    1e28:	77 95       	ror	r23
    1e2a:	67 95       	ror	r22
    1e2c:	ba 95       	dec	r27
    1e2e:	d1 f7       	brne	.-12     	; 0x1e24 <main+0x622>
    1e30:	9b 01       	movw	r18, r22
    1e32:	ac 01       	movw	r20, r24
    1e34:	0e 94 8f 13 	call	0x271e	; 0x271e <__mulsi3>
    1e38:	9b 01       	movw	r18, r22
    1e3a:	ac 01       	movw	r20, r24
    1e3c:	87 e0       	ldi	r24, 0x07	; 7
    1e3e:	55 95       	asr	r21
    1e40:	47 95       	ror	r20
    1e42:	37 95       	ror	r19
    1e44:	27 95       	ror	r18
    1e46:	8a 95       	dec	r24
    1e48:	d1 f7       	brne	.-12     	; 0x1e3e <main+0x63c>
                               ((int32_t)_bme280_calib.dig_H1)) >> 4));
    1e4a:	a0 91 56 03 	lds	r26, 0x0356	; 0x800356 <bme+0x27>
                    (((int32_t)_bme280_calib.dig_H5) * v_x1_u32r)) + ((int32_t)16384)) >> 15) *
                 (((((((v_x1_u32r * ((int32_t)_bme280_calib.dig_H6)) >> 10) *
                      (((v_x1_u32r * ((int32_t)_bme280_calib.dig_H3)) >> 11) + ((int32_t)32768))) >> 10) +
                    ((int32_t)2097152)) * ((int32_t)_bme280_calib.dig_H2) + 8192) >> 14));

    v_x1_u32r = (v_x1_u32r - (((((v_x1_u32r >> 15) * (v_x1_u32r >> 15)) >> 7) *
    1e4e:	b0 e0       	ldi	r27, 0x00	; 0
    1e50:	0e 94 c1 13 	call	0x2782	; 0x2782 <__muluhisi3>
                               ((int32_t)_bme280_calib.dig_H1)) >> 4));
    1e54:	24 e0       	ldi	r18, 0x04	; 4
    1e56:	95 95       	asr	r25
    1e58:	87 95       	ror	r24
    1e5a:	77 95       	ror	r23
    1e5c:	67 95       	ror	r22
    1e5e:	2a 95       	dec	r18
    1e60:	d1 f7       	brne	.-12     	; 0x1e56 <main+0x654>

    v_x1_u32r = (v_x1_u32r < 0) ? 0 : v_x1_u32r;
    1e62:	c6 1a       	sub	r12, r22
    1e64:	d7 0a       	sbc	r13, r23
    1e66:	e8 0a       	sbc	r14, r24
    1e68:	f9 0a       	sbc	r15, r25
    1e6a:	f7 fe       	sbrs	r15, 7
    1e6c:	03 c0       	rjmp	.+6      	; 0x1e74 <main+0x672>
    1e6e:	c1 2c       	mov	r12, r1
    1e70:	d1 2c       	mov	r13, r1
    1e72:	76 01       	movw	r14, r12
    v_x1_u32r = (v_x1_u32r > 419430400) ? 419430400 : v_x1_u32r;
    1e74:	c7 01       	movw	r24, r14
    1e76:	b6 01       	movw	r22, r12
    1e78:	61 30       	cpi	r22, 0x01	; 1
    1e7a:	71 05       	cpc	r23, r1
    1e7c:	81 05       	cpc	r24, r1
    1e7e:	e9 e1       	ldi	r30, 0x19	; 25
    1e80:	9e 07       	cpc	r25, r30
    1e82:	24 f0       	brlt	.+8      	; 0x1e8c <main+0x68a>
    1e84:	60 e0       	ldi	r22, 0x00	; 0
    1e86:	70 e0       	ldi	r23, 0x00	; 0
    1e88:	80 e0       	ldi	r24, 0x00	; 0
    1e8a:	99 e1       	ldi	r25, 0x19	; 25
    float h = (v_x1_u32r>>12);
    1e8c:	2c e0       	ldi	r18, 0x0C	; 12
    1e8e:	95 95       	asr	r25
    1e90:	87 95       	ror	r24
    1e92:	77 95       	ror	r23
    1e94:	67 95       	ror	r22
    1e96:	2a 95       	dec	r18
    1e98:	d1 f7       	brne	.-12     	; 0x1e8e <main+0x68c>
    1e9a:	0e 94 95 10 	call	0x212a	; 0x212a <__floatsisf>
    return  h / 1024.0;
    1e9e:	20 e0       	ldi	r18, 0x00	; 0
    1ea0:	30 e0       	ldi	r19, 0x00	; 0
    1ea2:	40 e8       	ldi	r20, 0x80	; 128
    1ea4:	5a e3       	ldi	r21, 0x3A	; 58
    1ea6:	0e 94 98 11 	call	0x2330	; 0x2330 <__mulsf3>
    1eaa:	42 e0       	ldi	r20, 0x02	; 2
    1eac:	0e 94 e7 04 	call	0x9ce	; 0x9ce <_ZN5Print10printFloatEdh.constprop.12>

    Serial.print("Humidity = ");
    Serial.print(bme.readHumidity());
    Serial.println(" %");
    1eb0:	81 ec       	ldi	r24, 0xC1	; 193
    1eb2:	91 e0       	ldi	r25, 0x01	; 1
    1eb4:	0e 94 d9 04 	call	0x9b2	; 0x9b2 <_ZN5Print7printlnEPKc.constprop.49>
    1eb8:	84 e2       	ldi	r24, 0x24	; 36
    1eba:	91 e0       	ldi	r25, 0x01	; 1
    1ebc:	0e 94 88 04 	call	0x910	; 0x910 <_ZN5Print5writeEPKc.part.2.constprop.52>
}


void loop() { 
    printValues();
    delay(delayTime);
    1ec0:	60 91 7e 02 	lds	r22, 0x027E	; 0x80027e <delayTime>
    1ec4:	70 91 7f 02 	lds	r23, 0x027F	; 0x80027f <delayTime+0x1>
    1ec8:	80 91 80 02 	lds	r24, 0x0280	; 0x800280 <delayTime+0x2>
    1ecc:	90 91 81 02 	lds	r25, 0x0281	; 0x800281 <delayTime+0x3>
    1ed0:	0e 94 ef 02 	call	0x5de	; 0x5de <delay>
    1ed4:	20 97       	sbiw	r28, 0x00	; 0
    1ed6:	09 f4       	brne	.+2      	; 0x1eda <main+0x6d8>
    1ed8:	be ce       	rjmp	.-644    	; 0x1c56 <main+0x454>
    1eda:	0e 94 42 01 	call	0x284	; 0x284 <_Z17Serial0_availablev>
    1ede:	88 23       	and	r24, r24
    1ee0:	09 f4       	brne	.+2      	; 0x1ee4 <main+0x6e2>
    1ee2:	b9 ce       	rjmp	.-654    	; 0x1c56 <main+0x454>
    1ee4:	0e 94 00 00 	call	0	; 0x0 <__vectors>
    1ee8:	b6 ce       	rjmp	.-660    	; 0x1c56 <main+0x454>
float Adafruit_BME280::readHumidity(void) {
    readTemperature(); // must be done first to get t_fine

    int32_t adc_H = read16(BME280_REGISTER_HUMIDDATA);
    if (adc_H == 0x8000) // value in case humidity measurement was disabled
        return NAN;
    1eea:	60 e0       	ldi	r22, 0x00	; 0
    1eec:	70 e0       	ldi	r23, 0x00	; 0
    1eee:	80 ec       	ldi	r24, 0xC0	; 192
    1ef0:	9f e7       	ldi	r25, 0x7F	; 127
    1ef2:	db cf       	rjmp	.-74     	; 0x1eaa <main+0x6a8>

00001ef4 <__subsf3>:
    1ef4:	50 58       	subi	r21, 0x80	; 128

00001ef6 <__addsf3>:
    1ef6:	bb 27       	eor	r27, r27
    1ef8:	aa 27       	eor	r26, r26
    1efa:	0e 94 92 0f 	call	0x1f24	; 0x1f24 <__addsf3x>
    1efe:	0c 94 59 11 	jmp	0x22b2	; 0x22b2 <__fp_round>
    1f02:	0e 94 4b 11 	call	0x2296	; 0x2296 <__fp_pscA>
    1f06:	38 f0       	brcs	.+14     	; 0x1f16 <__addsf3+0x20>
    1f08:	0e 94 52 11 	call	0x22a4	; 0x22a4 <__fp_pscB>
    1f0c:	20 f0       	brcs	.+8      	; 0x1f16 <__addsf3+0x20>
    1f0e:	39 f4       	brne	.+14     	; 0x1f1e <__addsf3+0x28>
    1f10:	9f 3f       	cpi	r25, 0xFF	; 255
    1f12:	19 f4       	brne	.+6      	; 0x1f1a <__addsf3+0x24>
    1f14:	26 f4       	brtc	.+8      	; 0x1f1e <__addsf3+0x28>
    1f16:	0c 94 38 11 	jmp	0x2270	; 0x2270 <__fp_nan>
    1f1a:	0e f4       	brtc	.+2      	; 0x1f1e <__addsf3+0x28>
    1f1c:	e0 95       	com	r30
    1f1e:	e7 fb       	bst	r30, 7
    1f20:	0c 94 32 11 	jmp	0x2264	; 0x2264 <__fp_inf>

00001f24 <__addsf3x>:
    1f24:	e9 2f       	mov	r30, r25
    1f26:	0e 94 6a 11 	call	0x22d4	; 0x22d4 <__fp_split3>
    1f2a:	58 f3       	brcs	.-42     	; 0x1f02 <__addsf3+0xc>
    1f2c:	ba 17       	cp	r27, r26
    1f2e:	62 07       	cpc	r22, r18
    1f30:	73 07       	cpc	r23, r19
    1f32:	84 07       	cpc	r24, r20
    1f34:	95 07       	cpc	r25, r21
    1f36:	20 f0       	brcs	.+8      	; 0x1f40 <__addsf3x+0x1c>
    1f38:	79 f4       	brne	.+30     	; 0x1f58 <__addsf3x+0x34>
    1f3a:	a6 f5       	brtc	.+104    	; 0x1fa4 <__addsf3x+0x80>
    1f3c:	0c 94 8c 11 	jmp	0x2318	; 0x2318 <__fp_zero>
    1f40:	0e f4       	brtc	.+2      	; 0x1f44 <__addsf3x+0x20>
    1f42:	e0 95       	com	r30
    1f44:	0b 2e       	mov	r0, r27
    1f46:	ba 2f       	mov	r27, r26
    1f48:	a0 2d       	mov	r26, r0
    1f4a:	0b 01       	movw	r0, r22
    1f4c:	b9 01       	movw	r22, r18
    1f4e:	90 01       	movw	r18, r0
    1f50:	0c 01       	movw	r0, r24
    1f52:	ca 01       	movw	r24, r20
    1f54:	a0 01       	movw	r20, r0
    1f56:	11 24       	eor	r1, r1
    1f58:	ff 27       	eor	r31, r31
    1f5a:	59 1b       	sub	r21, r25
    1f5c:	99 f0       	breq	.+38     	; 0x1f84 <__addsf3x+0x60>
    1f5e:	59 3f       	cpi	r21, 0xF9	; 249
    1f60:	50 f4       	brcc	.+20     	; 0x1f76 <__addsf3x+0x52>
    1f62:	50 3e       	cpi	r21, 0xE0	; 224
    1f64:	68 f1       	brcs	.+90     	; 0x1fc0 <__addsf3x+0x9c>
    1f66:	1a 16       	cp	r1, r26
    1f68:	f0 40       	sbci	r31, 0x00	; 0
    1f6a:	a2 2f       	mov	r26, r18
    1f6c:	23 2f       	mov	r18, r19
    1f6e:	34 2f       	mov	r19, r20
    1f70:	44 27       	eor	r20, r20
    1f72:	58 5f       	subi	r21, 0xF8	; 248
    1f74:	f3 cf       	rjmp	.-26     	; 0x1f5c <__addsf3x+0x38>
    1f76:	46 95       	lsr	r20
    1f78:	37 95       	ror	r19
    1f7a:	27 95       	ror	r18
    1f7c:	a7 95       	ror	r26
    1f7e:	f0 40       	sbci	r31, 0x00	; 0
    1f80:	53 95       	inc	r21
    1f82:	c9 f7       	brne	.-14     	; 0x1f76 <__addsf3x+0x52>
    1f84:	7e f4       	brtc	.+30     	; 0x1fa4 <__addsf3x+0x80>
    1f86:	1f 16       	cp	r1, r31
    1f88:	ba 0b       	sbc	r27, r26
    1f8a:	62 0b       	sbc	r22, r18
    1f8c:	73 0b       	sbc	r23, r19
    1f8e:	84 0b       	sbc	r24, r20
    1f90:	ba f0       	brmi	.+46     	; 0x1fc0 <__addsf3x+0x9c>
    1f92:	91 50       	subi	r25, 0x01	; 1
    1f94:	a1 f0       	breq	.+40     	; 0x1fbe <__addsf3x+0x9a>
    1f96:	ff 0f       	add	r31, r31
    1f98:	bb 1f       	adc	r27, r27
    1f9a:	66 1f       	adc	r22, r22
    1f9c:	77 1f       	adc	r23, r23
    1f9e:	88 1f       	adc	r24, r24
    1fa0:	c2 f7       	brpl	.-16     	; 0x1f92 <__addsf3x+0x6e>
    1fa2:	0e c0       	rjmp	.+28     	; 0x1fc0 <__addsf3x+0x9c>
    1fa4:	ba 0f       	add	r27, r26
    1fa6:	62 1f       	adc	r22, r18
    1fa8:	73 1f       	adc	r23, r19
    1faa:	84 1f       	adc	r24, r20
    1fac:	48 f4       	brcc	.+18     	; 0x1fc0 <__addsf3x+0x9c>
    1fae:	87 95       	ror	r24
    1fb0:	77 95       	ror	r23
    1fb2:	67 95       	ror	r22
    1fb4:	b7 95       	ror	r27
    1fb6:	f7 95       	ror	r31
    1fb8:	9e 3f       	cpi	r25, 0xFE	; 254
    1fba:	08 f0       	brcs	.+2      	; 0x1fbe <__addsf3x+0x9a>
    1fbc:	b0 cf       	rjmp	.-160    	; 0x1f1e <__addsf3+0x28>
    1fbe:	93 95       	inc	r25
    1fc0:	88 0f       	add	r24, r24
    1fc2:	08 f0       	brcs	.+2      	; 0x1fc6 <__addsf3x+0xa2>
    1fc4:	99 27       	eor	r25, r25
    1fc6:	ee 0f       	add	r30, r30
    1fc8:	97 95       	ror	r25
    1fca:	87 95       	ror	r24
    1fcc:	08 95       	ret

00001fce <__cmpsf2>:
    1fce:	0e 94 0e 11 	call	0x221c	; 0x221c <__fp_cmp>
    1fd2:	08 f4       	brcc	.+2      	; 0x1fd6 <__cmpsf2+0x8>
    1fd4:	81 e0       	ldi	r24, 0x01	; 1
    1fd6:	08 95       	ret

00001fd8 <__divsf3>:
    1fd8:	0e 94 00 10 	call	0x2000	; 0x2000 <__divsf3x>
    1fdc:	0c 94 59 11 	jmp	0x22b2	; 0x22b2 <__fp_round>
    1fe0:	0e 94 52 11 	call	0x22a4	; 0x22a4 <__fp_pscB>
    1fe4:	58 f0       	brcs	.+22     	; 0x1ffc <__divsf3+0x24>
    1fe6:	0e 94 4b 11 	call	0x2296	; 0x2296 <__fp_pscA>
    1fea:	40 f0       	brcs	.+16     	; 0x1ffc <__divsf3+0x24>
    1fec:	29 f4       	brne	.+10     	; 0x1ff8 <__divsf3+0x20>
    1fee:	5f 3f       	cpi	r21, 0xFF	; 255
    1ff0:	29 f0       	breq	.+10     	; 0x1ffc <__divsf3+0x24>
    1ff2:	0c 94 32 11 	jmp	0x2264	; 0x2264 <__fp_inf>
    1ff6:	51 11       	cpse	r21, r1
    1ff8:	0c 94 8d 11 	jmp	0x231a	; 0x231a <__fp_szero>
    1ffc:	0c 94 38 11 	jmp	0x2270	; 0x2270 <__fp_nan>

00002000 <__divsf3x>:
    2000:	0e 94 6a 11 	call	0x22d4	; 0x22d4 <__fp_split3>
    2004:	68 f3       	brcs	.-38     	; 0x1fe0 <__divsf3+0x8>

00002006 <__divsf3_pse>:
    2006:	99 23       	and	r25, r25
    2008:	b1 f3       	breq	.-20     	; 0x1ff6 <__divsf3+0x1e>
    200a:	55 23       	and	r21, r21
    200c:	91 f3       	breq	.-28     	; 0x1ff2 <__divsf3+0x1a>
    200e:	95 1b       	sub	r25, r21
    2010:	55 0b       	sbc	r21, r21
    2012:	bb 27       	eor	r27, r27
    2014:	aa 27       	eor	r26, r26
    2016:	62 17       	cp	r22, r18
    2018:	73 07       	cpc	r23, r19
    201a:	84 07       	cpc	r24, r20
    201c:	38 f0       	brcs	.+14     	; 0x202c <__divsf3_pse+0x26>
    201e:	9f 5f       	subi	r25, 0xFF	; 255
    2020:	5f 4f       	sbci	r21, 0xFF	; 255
    2022:	22 0f       	add	r18, r18
    2024:	33 1f       	adc	r19, r19
    2026:	44 1f       	adc	r20, r20
    2028:	aa 1f       	adc	r26, r26
    202a:	a9 f3       	breq	.-22     	; 0x2016 <__divsf3_pse+0x10>
    202c:	35 d0       	rcall	.+106    	; 0x2098 <__divsf3_pse+0x92>
    202e:	0e 2e       	mov	r0, r30
    2030:	3a f0       	brmi	.+14     	; 0x2040 <__divsf3_pse+0x3a>
    2032:	e0 e8       	ldi	r30, 0x80	; 128
    2034:	32 d0       	rcall	.+100    	; 0x209a <__divsf3_pse+0x94>
    2036:	91 50       	subi	r25, 0x01	; 1
    2038:	50 40       	sbci	r21, 0x00	; 0
    203a:	e6 95       	lsr	r30
    203c:	00 1c       	adc	r0, r0
    203e:	ca f7       	brpl	.-14     	; 0x2032 <__divsf3_pse+0x2c>
    2040:	2b d0       	rcall	.+86     	; 0x2098 <__divsf3_pse+0x92>
    2042:	fe 2f       	mov	r31, r30
    2044:	29 d0       	rcall	.+82     	; 0x2098 <__divsf3_pse+0x92>
    2046:	66 0f       	add	r22, r22
    2048:	77 1f       	adc	r23, r23
    204a:	88 1f       	adc	r24, r24
    204c:	bb 1f       	adc	r27, r27
    204e:	26 17       	cp	r18, r22
    2050:	37 07       	cpc	r19, r23
    2052:	48 07       	cpc	r20, r24
    2054:	ab 07       	cpc	r26, r27
    2056:	b0 e8       	ldi	r27, 0x80	; 128
    2058:	09 f0       	breq	.+2      	; 0x205c <__divsf3_pse+0x56>
    205a:	bb 0b       	sbc	r27, r27
    205c:	80 2d       	mov	r24, r0
    205e:	bf 01       	movw	r22, r30
    2060:	ff 27       	eor	r31, r31
    2062:	93 58       	subi	r25, 0x83	; 131
    2064:	5f 4f       	sbci	r21, 0xFF	; 255
    2066:	3a f0       	brmi	.+14     	; 0x2076 <__divsf3_pse+0x70>
    2068:	9e 3f       	cpi	r25, 0xFE	; 254
    206a:	51 05       	cpc	r21, r1
    206c:	78 f0       	brcs	.+30     	; 0x208c <__divsf3_pse+0x86>
    206e:	0c 94 32 11 	jmp	0x2264	; 0x2264 <__fp_inf>
    2072:	0c 94 8d 11 	jmp	0x231a	; 0x231a <__fp_szero>
    2076:	5f 3f       	cpi	r21, 0xFF	; 255
    2078:	e4 f3       	brlt	.-8      	; 0x2072 <__divsf3_pse+0x6c>
    207a:	98 3e       	cpi	r25, 0xE8	; 232
    207c:	d4 f3       	brlt	.-12     	; 0x2072 <__divsf3_pse+0x6c>
    207e:	86 95       	lsr	r24
    2080:	77 95       	ror	r23
    2082:	67 95       	ror	r22
    2084:	b7 95       	ror	r27
    2086:	f7 95       	ror	r31
    2088:	9f 5f       	subi	r25, 0xFF	; 255
    208a:	c9 f7       	brne	.-14     	; 0x207e <__divsf3_pse+0x78>
    208c:	88 0f       	add	r24, r24
    208e:	91 1d       	adc	r25, r1
    2090:	96 95       	lsr	r25
    2092:	87 95       	ror	r24
    2094:	97 f9       	bld	r25, 7
    2096:	08 95       	ret
    2098:	e1 e0       	ldi	r30, 0x01	; 1
    209a:	66 0f       	add	r22, r22
    209c:	77 1f       	adc	r23, r23
    209e:	88 1f       	adc	r24, r24
    20a0:	bb 1f       	adc	r27, r27
    20a2:	62 17       	cp	r22, r18
    20a4:	73 07       	cpc	r23, r19
    20a6:	84 07       	cpc	r24, r20
    20a8:	ba 07       	cpc	r27, r26
    20aa:	20 f0       	brcs	.+8      	; 0x20b4 <__divsf3_pse+0xae>
    20ac:	62 1b       	sub	r22, r18
    20ae:	73 0b       	sbc	r23, r19
    20b0:	84 0b       	sbc	r24, r20
    20b2:	ba 0b       	sbc	r27, r26
    20b4:	ee 1f       	adc	r30, r30
    20b6:	88 f7       	brcc	.-30     	; 0x209a <__divsf3_pse+0x94>
    20b8:	e0 95       	com	r30
    20ba:	08 95       	ret

000020bc <__fixunssfsi>:
    20bc:	0e 94 72 11 	call	0x22e4	; 0x22e4 <__fp_splitA>
    20c0:	88 f0       	brcs	.+34     	; 0x20e4 <__fixunssfsi+0x28>
    20c2:	9f 57       	subi	r25, 0x7F	; 127
    20c4:	98 f0       	brcs	.+38     	; 0x20ec <__fixunssfsi+0x30>
    20c6:	b9 2f       	mov	r27, r25
    20c8:	99 27       	eor	r25, r25
    20ca:	b7 51       	subi	r27, 0x17	; 23
    20cc:	b0 f0       	brcs	.+44     	; 0x20fa <__fixunssfsi+0x3e>
    20ce:	e1 f0       	breq	.+56     	; 0x2108 <__fixunssfsi+0x4c>
    20d0:	66 0f       	add	r22, r22
    20d2:	77 1f       	adc	r23, r23
    20d4:	88 1f       	adc	r24, r24
    20d6:	99 1f       	adc	r25, r25
    20d8:	1a f0       	brmi	.+6      	; 0x20e0 <__fixunssfsi+0x24>
    20da:	ba 95       	dec	r27
    20dc:	c9 f7       	brne	.-14     	; 0x20d0 <__fixunssfsi+0x14>
    20de:	14 c0       	rjmp	.+40     	; 0x2108 <__fixunssfsi+0x4c>
    20e0:	b1 30       	cpi	r27, 0x01	; 1
    20e2:	91 f0       	breq	.+36     	; 0x2108 <__fixunssfsi+0x4c>
    20e4:	0e 94 8c 11 	call	0x2318	; 0x2318 <__fp_zero>
    20e8:	b1 e0       	ldi	r27, 0x01	; 1
    20ea:	08 95       	ret
    20ec:	0c 94 8c 11 	jmp	0x2318	; 0x2318 <__fp_zero>
    20f0:	67 2f       	mov	r22, r23
    20f2:	78 2f       	mov	r23, r24
    20f4:	88 27       	eor	r24, r24
    20f6:	b8 5f       	subi	r27, 0xF8	; 248
    20f8:	39 f0       	breq	.+14     	; 0x2108 <__fixunssfsi+0x4c>
    20fa:	b9 3f       	cpi	r27, 0xF9	; 249
    20fc:	cc f3       	brlt	.-14     	; 0x20f0 <__fixunssfsi+0x34>
    20fe:	86 95       	lsr	r24
    2100:	77 95       	ror	r23
    2102:	67 95       	ror	r22
    2104:	b3 95       	inc	r27
    2106:	d9 f7       	brne	.-10     	; 0x20fe <__fixunssfsi+0x42>
    2108:	3e f4       	brtc	.+14     	; 0x2118 <__fixunssfsi+0x5c>
    210a:	90 95       	com	r25
    210c:	80 95       	com	r24
    210e:	70 95       	com	r23
    2110:	61 95       	neg	r22
    2112:	7f 4f       	sbci	r23, 0xFF	; 255
    2114:	8f 4f       	sbci	r24, 0xFF	; 255
    2116:	9f 4f       	sbci	r25, 0xFF	; 255
    2118:	08 95       	ret

0000211a <__floatdisf>:
    211a:	97 fb       	bst	r25, 7
    211c:	16 f4       	brtc	.+4      	; 0x2122 <__floatdisf+0x8>
    211e:	0e 94 3b 11 	call	0x2276	; 0x2276 <__fp_negdi>
    2122:	0c 94 d1 10 	jmp	0x21a2	; 0x21a2 <__fp_di2sf>

00002126 <__floatunsisf>:
    2126:	e8 94       	clt
    2128:	09 c0       	rjmp	.+18     	; 0x213c <__floatsisf+0x12>

0000212a <__floatsisf>:
    212a:	97 fb       	bst	r25, 7
    212c:	3e f4       	brtc	.+14     	; 0x213c <__floatsisf+0x12>
    212e:	90 95       	com	r25
    2130:	80 95       	com	r24
    2132:	70 95       	com	r23
    2134:	61 95       	neg	r22
    2136:	7f 4f       	sbci	r23, 0xFF	; 255
    2138:	8f 4f       	sbci	r24, 0xFF	; 255
    213a:	9f 4f       	sbci	r25, 0xFF	; 255
    213c:	99 23       	and	r25, r25
    213e:	a9 f0       	breq	.+42     	; 0x216a <__floatsisf+0x40>
    2140:	f9 2f       	mov	r31, r25
    2142:	96 e9       	ldi	r25, 0x96	; 150
    2144:	bb 27       	eor	r27, r27
    2146:	93 95       	inc	r25
    2148:	f6 95       	lsr	r31
    214a:	87 95       	ror	r24
    214c:	77 95       	ror	r23
    214e:	67 95       	ror	r22
    2150:	b7 95       	ror	r27
    2152:	f1 11       	cpse	r31, r1
    2154:	f8 cf       	rjmp	.-16     	; 0x2146 <__floatsisf+0x1c>
    2156:	fa f4       	brpl	.+62     	; 0x2196 <__floatsisf+0x6c>
    2158:	bb 0f       	add	r27, r27
    215a:	11 f4       	brne	.+4      	; 0x2160 <__floatsisf+0x36>
    215c:	60 ff       	sbrs	r22, 0
    215e:	1b c0       	rjmp	.+54     	; 0x2196 <__floatsisf+0x6c>
    2160:	6f 5f       	subi	r22, 0xFF	; 255
    2162:	7f 4f       	sbci	r23, 0xFF	; 255
    2164:	8f 4f       	sbci	r24, 0xFF	; 255
    2166:	9f 4f       	sbci	r25, 0xFF	; 255
    2168:	16 c0       	rjmp	.+44     	; 0x2196 <__floatsisf+0x6c>
    216a:	88 23       	and	r24, r24
    216c:	11 f0       	breq	.+4      	; 0x2172 <__floatsisf+0x48>
    216e:	96 e9       	ldi	r25, 0x96	; 150
    2170:	11 c0       	rjmp	.+34     	; 0x2194 <__floatsisf+0x6a>
    2172:	77 23       	and	r23, r23
    2174:	21 f0       	breq	.+8      	; 0x217e <__floatsisf+0x54>
    2176:	9e e8       	ldi	r25, 0x8E	; 142
    2178:	87 2f       	mov	r24, r23
    217a:	76 2f       	mov	r23, r22
    217c:	05 c0       	rjmp	.+10     	; 0x2188 <__floatsisf+0x5e>
    217e:	66 23       	and	r22, r22
    2180:	71 f0       	breq	.+28     	; 0x219e <__floatsisf+0x74>
    2182:	96 e8       	ldi	r25, 0x86	; 134
    2184:	86 2f       	mov	r24, r22
    2186:	70 e0       	ldi	r23, 0x00	; 0
    2188:	60 e0       	ldi	r22, 0x00	; 0
    218a:	2a f0       	brmi	.+10     	; 0x2196 <__floatsisf+0x6c>
    218c:	9a 95       	dec	r25
    218e:	66 0f       	add	r22, r22
    2190:	77 1f       	adc	r23, r23
    2192:	88 1f       	adc	r24, r24
    2194:	da f7       	brpl	.-10     	; 0x218c <__floatsisf+0x62>
    2196:	88 0f       	add	r24, r24
    2198:	96 95       	lsr	r25
    219a:	87 95       	ror	r24
    219c:	97 f9       	bld	r25, 7
    219e:	08 95       	ret

000021a0 <__floatundisf>:
    21a0:	e8 94       	clt

000021a2 <__fp_di2sf>:
    21a2:	f9 2f       	mov	r31, r25
    21a4:	96 eb       	ldi	r25, 0xB6	; 182
    21a6:	ff 23       	and	r31, r31
    21a8:	81 f0       	breq	.+32     	; 0x21ca <__fp_di2sf+0x28>
    21aa:	12 16       	cp	r1, r18
    21ac:	13 06       	cpc	r1, r19
    21ae:	14 06       	cpc	r1, r20
    21b0:	44 0b       	sbc	r20, r20
    21b2:	93 95       	inc	r25
    21b4:	f6 95       	lsr	r31
    21b6:	87 95       	ror	r24
    21b8:	77 95       	ror	r23
    21ba:	67 95       	ror	r22
    21bc:	57 95       	ror	r21
    21be:	40 40       	sbci	r20, 0x00	; 0
    21c0:	ff 23       	and	r31, r31
    21c2:	b9 f7       	brne	.-18     	; 0x21b2 <__fp_di2sf+0x10>
    21c4:	1b c0       	rjmp	.+54     	; 0x21fc <__fp_di2sf+0x5a>
    21c6:	99 27       	eor	r25, r25
    21c8:	08 95       	ret
    21ca:	88 23       	and	r24, r24
    21cc:	51 f4       	brne	.+20     	; 0x21e2 <__fp_di2sf+0x40>
    21ce:	98 50       	subi	r25, 0x08	; 8
    21d0:	d2 f7       	brpl	.-12     	; 0x21c6 <__fp_di2sf+0x24>
    21d2:	87 2b       	or	r24, r23
    21d4:	76 2f       	mov	r23, r22
    21d6:	65 2f       	mov	r22, r21
    21d8:	54 2f       	mov	r21, r20
    21da:	43 2f       	mov	r20, r19
    21dc:	32 2f       	mov	r19, r18
    21de:	20 e0       	ldi	r18, 0x00	; 0
    21e0:	b1 f3       	breq	.-20     	; 0x21ce <__fp_di2sf+0x2c>
    21e2:	12 16       	cp	r1, r18
    21e4:	13 06       	cpc	r1, r19
    21e6:	14 06       	cpc	r1, r20
    21e8:	44 0b       	sbc	r20, r20
    21ea:	88 23       	and	r24, r24
    21ec:	3a f0       	brmi	.+14     	; 0x21fc <__fp_di2sf+0x5a>
    21ee:	9a 95       	dec	r25
    21f0:	44 0f       	add	r20, r20
    21f2:	55 1f       	adc	r21, r21
    21f4:	66 1f       	adc	r22, r22
    21f6:	77 1f       	adc	r23, r23
    21f8:	88 1f       	adc	r24, r24
    21fa:	ca f7       	brpl	.-14     	; 0x21ee <__fp_di2sf+0x4c>
    21fc:	55 23       	and	r21, r21
    21fe:	4a f4       	brpl	.+18     	; 0x2212 <__fp_di2sf+0x70>
    2200:	44 0f       	add	r20, r20
    2202:	55 1f       	adc	r21, r21
    2204:	11 f4       	brne	.+4      	; 0x220a <__fp_di2sf+0x68>
    2206:	60 ff       	sbrs	r22, 0
    2208:	04 c0       	rjmp	.+8      	; 0x2212 <__fp_di2sf+0x70>
    220a:	6f 5f       	subi	r22, 0xFF	; 255
    220c:	7f 4f       	sbci	r23, 0xFF	; 255
    220e:	8f 4f       	sbci	r24, 0xFF	; 255
    2210:	9f 4f       	sbci	r25, 0xFF	; 255
    2212:	88 0f       	add	r24, r24
    2214:	96 95       	lsr	r25
    2216:	87 95       	ror	r24
    2218:	97 f9       	bld	r25, 7
    221a:	08 95       	ret

0000221c <__fp_cmp>:
    221c:	99 0f       	add	r25, r25
    221e:	00 08       	sbc	r0, r0
    2220:	55 0f       	add	r21, r21
    2222:	aa 0b       	sbc	r26, r26
    2224:	e0 e8       	ldi	r30, 0x80	; 128
    2226:	fe ef       	ldi	r31, 0xFE	; 254
    2228:	16 16       	cp	r1, r22
    222a:	17 06       	cpc	r1, r23
    222c:	e8 07       	cpc	r30, r24
    222e:	f9 07       	cpc	r31, r25
    2230:	c0 f0       	brcs	.+48     	; 0x2262 <__fp_cmp+0x46>
    2232:	12 16       	cp	r1, r18
    2234:	13 06       	cpc	r1, r19
    2236:	e4 07       	cpc	r30, r20
    2238:	f5 07       	cpc	r31, r21
    223a:	98 f0       	brcs	.+38     	; 0x2262 <__fp_cmp+0x46>
    223c:	62 1b       	sub	r22, r18
    223e:	73 0b       	sbc	r23, r19
    2240:	84 0b       	sbc	r24, r20
    2242:	95 0b       	sbc	r25, r21
    2244:	39 f4       	brne	.+14     	; 0x2254 <__fp_cmp+0x38>
    2246:	0a 26       	eor	r0, r26
    2248:	61 f0       	breq	.+24     	; 0x2262 <__fp_cmp+0x46>
    224a:	23 2b       	or	r18, r19
    224c:	24 2b       	or	r18, r20
    224e:	25 2b       	or	r18, r21
    2250:	21 f4       	brne	.+8      	; 0x225a <__fp_cmp+0x3e>
    2252:	08 95       	ret
    2254:	0a 26       	eor	r0, r26
    2256:	09 f4       	brne	.+2      	; 0x225a <__fp_cmp+0x3e>
    2258:	a1 40       	sbci	r26, 0x01	; 1
    225a:	a6 95       	lsr	r26
    225c:	8f ef       	ldi	r24, 0xFF	; 255
    225e:	81 1d       	adc	r24, r1
    2260:	81 1d       	adc	r24, r1
    2262:	08 95       	ret

00002264 <__fp_inf>:
    2264:	97 f9       	bld	r25, 7
    2266:	9f 67       	ori	r25, 0x7F	; 127
    2268:	80 e8       	ldi	r24, 0x80	; 128
    226a:	70 e0       	ldi	r23, 0x00	; 0
    226c:	60 e0       	ldi	r22, 0x00	; 0
    226e:	08 95       	ret

00002270 <__fp_nan>:
    2270:	9f ef       	ldi	r25, 0xFF	; 255
    2272:	80 ec       	ldi	r24, 0xC0	; 192
    2274:	08 95       	ret

00002276 <__fp_negdi>:
    2276:	90 95       	com	r25
    2278:	80 95       	com	r24
    227a:	70 95       	com	r23
    227c:	60 95       	com	r22
    227e:	50 95       	com	r21
    2280:	40 95       	com	r20
    2282:	30 95       	com	r19
    2284:	21 95       	neg	r18
    2286:	3f 4f       	sbci	r19, 0xFF	; 255
    2288:	4f 4f       	sbci	r20, 0xFF	; 255
    228a:	5f 4f       	sbci	r21, 0xFF	; 255
    228c:	6f 4f       	sbci	r22, 0xFF	; 255
    228e:	7f 4f       	sbci	r23, 0xFF	; 255
    2290:	8f 4f       	sbci	r24, 0xFF	; 255
    2292:	9f 4f       	sbci	r25, 0xFF	; 255
    2294:	08 95       	ret

00002296 <__fp_pscA>:
    2296:	00 24       	eor	r0, r0
    2298:	0a 94       	dec	r0
    229a:	16 16       	cp	r1, r22
    229c:	17 06       	cpc	r1, r23
    229e:	18 06       	cpc	r1, r24
    22a0:	09 06       	cpc	r0, r25
    22a2:	08 95       	ret

000022a4 <__fp_pscB>:
    22a4:	00 24       	eor	r0, r0
    22a6:	0a 94       	dec	r0
    22a8:	12 16       	cp	r1, r18
    22aa:	13 06       	cpc	r1, r19
    22ac:	14 06       	cpc	r1, r20
    22ae:	05 06       	cpc	r0, r21
    22b0:	08 95       	ret

000022b2 <__fp_round>:
    22b2:	09 2e       	mov	r0, r25
    22b4:	03 94       	inc	r0
    22b6:	00 0c       	add	r0, r0
    22b8:	11 f4       	brne	.+4      	; 0x22be <__fp_round+0xc>
    22ba:	88 23       	and	r24, r24
    22bc:	52 f0       	brmi	.+20     	; 0x22d2 <__fp_round+0x20>
    22be:	bb 0f       	add	r27, r27
    22c0:	40 f4       	brcc	.+16     	; 0x22d2 <__fp_round+0x20>
    22c2:	bf 2b       	or	r27, r31
    22c4:	11 f4       	brne	.+4      	; 0x22ca <__fp_round+0x18>
    22c6:	60 ff       	sbrs	r22, 0
    22c8:	04 c0       	rjmp	.+8      	; 0x22d2 <__fp_round+0x20>
    22ca:	6f 5f       	subi	r22, 0xFF	; 255
    22cc:	7f 4f       	sbci	r23, 0xFF	; 255
    22ce:	8f 4f       	sbci	r24, 0xFF	; 255
    22d0:	9f 4f       	sbci	r25, 0xFF	; 255
    22d2:	08 95       	ret

000022d4 <__fp_split3>:
    22d4:	57 fd       	sbrc	r21, 7
    22d6:	90 58       	subi	r25, 0x80	; 128
    22d8:	44 0f       	add	r20, r20
    22da:	55 1f       	adc	r21, r21
    22dc:	59 f0       	breq	.+22     	; 0x22f4 <__fp_splitA+0x10>
    22de:	5f 3f       	cpi	r21, 0xFF	; 255
    22e0:	71 f0       	breq	.+28     	; 0x22fe <__fp_splitA+0x1a>
    22e2:	47 95       	ror	r20

000022e4 <__fp_splitA>:
    22e4:	88 0f       	add	r24, r24
    22e6:	97 fb       	bst	r25, 7
    22e8:	99 1f       	adc	r25, r25
    22ea:	61 f0       	breq	.+24     	; 0x2304 <__fp_splitA+0x20>
    22ec:	9f 3f       	cpi	r25, 0xFF	; 255
    22ee:	79 f0       	breq	.+30     	; 0x230e <__fp_splitA+0x2a>
    22f0:	87 95       	ror	r24
    22f2:	08 95       	ret
    22f4:	12 16       	cp	r1, r18
    22f6:	13 06       	cpc	r1, r19
    22f8:	14 06       	cpc	r1, r20
    22fa:	55 1f       	adc	r21, r21
    22fc:	f2 cf       	rjmp	.-28     	; 0x22e2 <__fp_split3+0xe>
    22fe:	46 95       	lsr	r20
    2300:	f1 df       	rcall	.-30     	; 0x22e4 <__fp_splitA>
    2302:	08 c0       	rjmp	.+16     	; 0x2314 <__fp_splitA+0x30>
    2304:	16 16       	cp	r1, r22
    2306:	17 06       	cpc	r1, r23
    2308:	18 06       	cpc	r1, r24
    230a:	99 1f       	adc	r25, r25
    230c:	f1 cf       	rjmp	.-30     	; 0x22f0 <__fp_splitA+0xc>
    230e:	86 95       	lsr	r24
    2310:	71 05       	cpc	r23, r1
    2312:	61 05       	cpc	r22, r1
    2314:	08 94       	sec
    2316:	08 95       	ret

00002318 <__fp_zero>:
    2318:	e8 94       	clt

0000231a <__fp_szero>:
    231a:	bb 27       	eor	r27, r27
    231c:	66 27       	eor	r22, r22
    231e:	77 27       	eor	r23, r23
    2320:	cb 01       	movw	r24, r22
    2322:	97 f9       	bld	r25, 7
    2324:	08 95       	ret

00002326 <__gesf2>:
    2326:	0e 94 0e 11 	call	0x221c	; 0x221c <__fp_cmp>
    232a:	08 f4       	brcc	.+2      	; 0x232e <__gesf2+0x8>
    232c:	8f ef       	ldi	r24, 0xFF	; 255
    232e:	08 95       	ret

00002330 <__mulsf3>:
    2330:	0e 94 ab 11 	call	0x2356	; 0x2356 <__mulsf3x>
    2334:	0c 94 59 11 	jmp	0x22b2	; 0x22b2 <__fp_round>
    2338:	0e 94 4b 11 	call	0x2296	; 0x2296 <__fp_pscA>
    233c:	38 f0       	brcs	.+14     	; 0x234c <__mulsf3+0x1c>
    233e:	0e 94 52 11 	call	0x22a4	; 0x22a4 <__fp_pscB>
    2342:	20 f0       	brcs	.+8      	; 0x234c <__mulsf3+0x1c>
    2344:	95 23       	and	r25, r21
    2346:	11 f0       	breq	.+4      	; 0x234c <__mulsf3+0x1c>
    2348:	0c 94 32 11 	jmp	0x2264	; 0x2264 <__fp_inf>
    234c:	0c 94 38 11 	jmp	0x2270	; 0x2270 <__fp_nan>
    2350:	11 24       	eor	r1, r1
    2352:	0c 94 8d 11 	jmp	0x231a	; 0x231a <__fp_szero>

00002356 <__mulsf3x>:
    2356:	0e 94 6a 11 	call	0x22d4	; 0x22d4 <__fp_split3>
    235a:	70 f3       	brcs	.-36     	; 0x2338 <__mulsf3+0x8>

0000235c <__mulsf3_pse>:
    235c:	95 9f       	mul	r25, r21
    235e:	c1 f3       	breq	.-16     	; 0x2350 <__mulsf3+0x20>
    2360:	95 0f       	add	r25, r21
    2362:	50 e0       	ldi	r21, 0x00	; 0
    2364:	55 1f       	adc	r21, r21
    2366:	62 9f       	mul	r22, r18
    2368:	f0 01       	movw	r30, r0
    236a:	72 9f       	mul	r23, r18
    236c:	bb 27       	eor	r27, r27
    236e:	f0 0d       	add	r31, r0
    2370:	b1 1d       	adc	r27, r1
    2372:	63 9f       	mul	r22, r19
    2374:	aa 27       	eor	r26, r26
    2376:	f0 0d       	add	r31, r0
    2378:	b1 1d       	adc	r27, r1
    237a:	aa 1f       	adc	r26, r26
    237c:	64 9f       	mul	r22, r20
    237e:	66 27       	eor	r22, r22
    2380:	b0 0d       	add	r27, r0
    2382:	a1 1d       	adc	r26, r1
    2384:	66 1f       	adc	r22, r22
    2386:	82 9f       	mul	r24, r18
    2388:	22 27       	eor	r18, r18
    238a:	b0 0d       	add	r27, r0
    238c:	a1 1d       	adc	r26, r1
    238e:	62 1f       	adc	r22, r18
    2390:	73 9f       	mul	r23, r19
    2392:	b0 0d       	add	r27, r0
    2394:	a1 1d       	adc	r26, r1
    2396:	62 1f       	adc	r22, r18
    2398:	83 9f       	mul	r24, r19
    239a:	a0 0d       	add	r26, r0
    239c:	61 1d       	adc	r22, r1
    239e:	22 1f       	adc	r18, r18
    23a0:	74 9f       	mul	r23, r20
    23a2:	33 27       	eor	r19, r19
    23a4:	a0 0d       	add	r26, r0
    23a6:	61 1d       	adc	r22, r1
    23a8:	23 1f       	adc	r18, r19
    23aa:	84 9f       	mul	r24, r20
    23ac:	60 0d       	add	r22, r0
    23ae:	21 1d       	adc	r18, r1
    23b0:	82 2f       	mov	r24, r18
    23b2:	76 2f       	mov	r23, r22
    23b4:	6a 2f       	mov	r22, r26
    23b6:	11 24       	eor	r1, r1
    23b8:	9f 57       	subi	r25, 0x7F	; 127
    23ba:	50 40       	sbci	r21, 0x00	; 0
    23bc:	9a f0       	brmi	.+38     	; 0x23e4 <__mulsf3_pse+0x88>
    23be:	f1 f0       	breq	.+60     	; 0x23fc <__mulsf3_pse+0xa0>
    23c0:	88 23       	and	r24, r24
    23c2:	4a f0       	brmi	.+18     	; 0x23d6 <__mulsf3_pse+0x7a>
    23c4:	ee 0f       	add	r30, r30
    23c6:	ff 1f       	adc	r31, r31
    23c8:	bb 1f       	adc	r27, r27
    23ca:	66 1f       	adc	r22, r22
    23cc:	77 1f       	adc	r23, r23
    23ce:	88 1f       	adc	r24, r24
    23d0:	91 50       	subi	r25, 0x01	; 1
    23d2:	50 40       	sbci	r21, 0x00	; 0
    23d4:	a9 f7       	brne	.-22     	; 0x23c0 <__mulsf3_pse+0x64>
    23d6:	9e 3f       	cpi	r25, 0xFE	; 254
    23d8:	51 05       	cpc	r21, r1
    23da:	80 f0       	brcs	.+32     	; 0x23fc <__mulsf3_pse+0xa0>
    23dc:	0c 94 32 11 	jmp	0x2264	; 0x2264 <__fp_inf>
    23e0:	0c 94 8d 11 	jmp	0x231a	; 0x231a <__fp_szero>
    23e4:	5f 3f       	cpi	r21, 0xFF	; 255
    23e6:	e4 f3       	brlt	.-8      	; 0x23e0 <__mulsf3_pse+0x84>
    23e8:	98 3e       	cpi	r25, 0xE8	; 232
    23ea:	d4 f3       	brlt	.-12     	; 0x23e0 <__mulsf3_pse+0x84>
    23ec:	86 95       	lsr	r24
    23ee:	77 95       	ror	r23
    23f0:	67 95       	ror	r22
    23f2:	b7 95       	ror	r27
    23f4:	f7 95       	ror	r31
    23f6:	e7 95       	ror	r30
    23f8:	9f 5f       	subi	r25, 0xFF	; 255
    23fa:	c1 f7       	brne	.-16     	; 0x23ec <__mulsf3_pse+0x90>
    23fc:	fe 2b       	or	r31, r30
    23fe:	88 0f       	add	r24, r24
    2400:	91 1d       	adc	r25, r1
    2402:	96 95       	lsr	r25
    2404:	87 95       	ror	r24
    2406:	97 f9       	bld	r25, 7
    2408:	08 95       	ret

0000240a <pow>:
    240a:	fa 01       	movw	r30, r20
    240c:	ee 0f       	add	r30, r30
    240e:	ff 1f       	adc	r31, r31
    2410:	30 96       	adiw	r30, 0x00	; 0
    2412:	21 05       	cpc	r18, r1
    2414:	31 05       	cpc	r19, r1
    2416:	a1 f1       	breq	.+104    	; 0x2480 <pow+0x76>
    2418:	61 15       	cp	r22, r1
    241a:	71 05       	cpc	r23, r1
    241c:	61 f4       	brne	.+24     	; 0x2436 <pow+0x2c>
    241e:	80 38       	cpi	r24, 0x80	; 128
    2420:	bf e3       	ldi	r27, 0x3F	; 63
    2422:	9b 07       	cpc	r25, r27
    2424:	49 f1       	breq	.+82     	; 0x2478 <pow+0x6e>
    2426:	68 94       	set
    2428:	90 38       	cpi	r25, 0x80	; 128
    242a:	81 05       	cpc	r24, r1
    242c:	61 f0       	breq	.+24     	; 0x2446 <pow+0x3c>
    242e:	80 38       	cpi	r24, 0x80	; 128
    2430:	bf ef       	ldi	r27, 0xFF	; 255
    2432:	9b 07       	cpc	r25, r27
    2434:	41 f0       	breq	.+16     	; 0x2446 <pow+0x3c>
    2436:	99 23       	and	r25, r25
    2438:	4a f5       	brpl	.+82     	; 0x248c <pow+0x82>
    243a:	ff 3f       	cpi	r31, 0xFF	; 255
    243c:	e1 05       	cpc	r30, r1
    243e:	31 05       	cpc	r19, r1
    2440:	21 05       	cpc	r18, r1
    2442:	19 f1       	breq	.+70     	; 0x248a <pow+0x80>
    2444:	e8 94       	clt
    2446:	08 94       	sec
    2448:	e7 95       	ror	r30
    244a:	d9 01       	movw	r26, r18
    244c:	aa 23       	and	r26, r26
    244e:	29 f4       	brne	.+10     	; 0x245a <pow+0x50>
    2450:	ab 2f       	mov	r26, r27
    2452:	be 2f       	mov	r27, r30
    2454:	f8 5f       	subi	r31, 0xF8	; 248
    2456:	d0 f3       	brcs	.-12     	; 0x244c <pow+0x42>
    2458:	10 c0       	rjmp	.+32     	; 0x247a <pow+0x70>
    245a:	ff 5f       	subi	r31, 0xFF	; 255
    245c:	70 f4       	brcc	.+28     	; 0x247a <pow+0x70>
    245e:	a6 95       	lsr	r26
    2460:	e0 f7       	brcc	.-8      	; 0x245a <pow+0x50>
    2462:	f7 39       	cpi	r31, 0x97	; 151
    2464:	50 f0       	brcs	.+20     	; 0x247a <pow+0x70>
    2466:	19 f0       	breq	.+6      	; 0x246e <pow+0x64>
    2468:	ff 3a       	cpi	r31, 0xAF	; 175
    246a:	38 f4       	brcc	.+14     	; 0x247a <pow+0x70>
    246c:	9f 77       	andi	r25, 0x7F	; 127
    246e:	9f 93       	push	r25
    2470:	0d d0       	rcall	.+26     	; 0x248c <pow+0x82>
    2472:	0f 90       	pop	r0
    2474:	07 fc       	sbrc	r0, 7
    2476:	90 58       	subi	r25, 0x80	; 128
    2478:	08 95       	ret
    247a:	46 f0       	brts	.+16     	; 0x248c <pow+0x82>
    247c:	0c 94 38 11 	jmp	0x2270	; 0x2270 <__fp_nan>
    2480:	60 e0       	ldi	r22, 0x00	; 0
    2482:	70 e0       	ldi	r23, 0x00	; 0
    2484:	80 e8       	ldi	r24, 0x80	; 128
    2486:	9f e3       	ldi	r25, 0x3F	; 63
    2488:	08 95       	ret
    248a:	4f e7       	ldi	r20, 0x7F	; 127
    248c:	9f 77       	andi	r25, 0x7F	; 127
    248e:	5f 93       	push	r21
    2490:	4f 93       	push	r20
    2492:	3f 93       	push	r19
    2494:	2f 93       	push	r18
    2496:	0e 94 05 13 	call	0x260a	; 0x260a <log>
    249a:	2f 91       	pop	r18
    249c:	3f 91       	pop	r19
    249e:	4f 91       	pop	r20
    24a0:	5f 91       	pop	r21
    24a2:	0e 94 98 11 	call	0x2330	; 0x2330 <__mulsf3>
    24a6:	0c 94 62 12 	jmp	0x24c4	; 0x24c4 <exp>

000024aa <__unordsf2>:
    24aa:	0e 94 0e 11 	call	0x221c	; 0x221c <__fp_cmp>
    24ae:	88 0b       	sbc	r24, r24
    24b0:	99 0b       	sbc	r25, r25
    24b2:	08 95       	ret
    24b4:	29 f4       	brne	.+10     	; 0x24c0 <__unordsf2+0x16>
    24b6:	16 f0       	brts	.+4      	; 0x24bc <__unordsf2+0x12>
    24b8:	0c 94 32 11 	jmp	0x2264	; 0x2264 <__fp_inf>
    24bc:	0c 94 8c 11 	jmp	0x2318	; 0x2318 <__fp_zero>
    24c0:	0c 94 38 11 	jmp	0x2270	; 0x2270 <__fp_nan>

000024c4 <exp>:
    24c4:	0e 94 72 11 	call	0x22e4	; 0x22e4 <__fp_splitA>
    24c8:	a8 f3       	brcs	.-22     	; 0x24b4 <__unordsf2+0xa>
    24ca:	96 38       	cpi	r25, 0x86	; 134
    24cc:	a0 f7       	brcc	.-24     	; 0x24b6 <__unordsf2+0xc>
    24ce:	07 f8       	bld	r0, 7
    24d0:	0f 92       	push	r0
    24d2:	e8 94       	clt
    24d4:	2b e3       	ldi	r18, 0x3B	; 59
    24d6:	3a ea       	ldi	r19, 0xAA	; 170
    24d8:	48 eb       	ldi	r20, 0xB8	; 184
    24da:	5f e7       	ldi	r21, 0x7F	; 127
    24dc:	0e 94 ae 11 	call	0x235c	; 0x235c <__mulsf3_pse>
    24e0:	0f 92       	push	r0
    24e2:	0f 92       	push	r0
    24e4:	0f 92       	push	r0
    24e6:	4d b7       	in	r20, 0x3d	; 61
    24e8:	5e b7       	in	r21, 0x3e	; 62
    24ea:	0f 92       	push	r0
    24ec:	0e 94 4d 13 	call	0x269a	; 0x269a <modf>
    24f0:	e8 e6       	ldi	r30, 0x68	; 104
    24f2:	f0 e0       	ldi	r31, 0x00	; 0
    24f4:	0e 94 94 12 	call	0x2528	; 0x2528 <__fp_powser>
    24f8:	4f 91       	pop	r20
    24fa:	5f 91       	pop	r21
    24fc:	ef 91       	pop	r30
    24fe:	ff 91       	pop	r31
    2500:	e5 95       	asr	r30
    2502:	ee 1f       	adc	r30, r30
    2504:	ff 1f       	adc	r31, r31
    2506:	49 f0       	breq	.+18     	; 0x251a <exp+0x56>
    2508:	fe 57       	subi	r31, 0x7E	; 126
    250a:	e0 68       	ori	r30, 0x80	; 128
    250c:	44 27       	eor	r20, r20
    250e:	ee 0f       	add	r30, r30
    2510:	44 1f       	adc	r20, r20
    2512:	fa 95       	dec	r31
    2514:	e1 f7       	brne	.-8      	; 0x250e <exp+0x4a>
    2516:	41 95       	neg	r20
    2518:	55 0b       	sbc	r21, r21
    251a:	0e 94 c7 12 	call	0x258e	; 0x258e <ldexp>
    251e:	0f 90       	pop	r0
    2520:	07 fe       	sbrs	r0, 7
    2522:	0c 94 bb 12 	jmp	0x2576	; 0x2576 <inverse>
    2526:	08 95       	ret

00002528 <__fp_powser>:
    2528:	df 93       	push	r29
    252a:	cf 93       	push	r28
    252c:	1f 93       	push	r17
    252e:	0f 93       	push	r16
    2530:	ff 92       	push	r15
    2532:	ef 92       	push	r14
    2534:	df 92       	push	r13
    2536:	7b 01       	movw	r14, r22
    2538:	8c 01       	movw	r16, r24
    253a:	68 94       	set
    253c:	06 c0       	rjmp	.+12     	; 0x254a <__fp_powser+0x22>
    253e:	da 2e       	mov	r13, r26
    2540:	ef 01       	movw	r28, r30
    2542:	0e 94 ab 11 	call	0x2356	; 0x2356 <__mulsf3x>
    2546:	fe 01       	movw	r30, r28
    2548:	e8 94       	clt
    254a:	a5 91       	lpm	r26, Z+
    254c:	25 91       	lpm	r18, Z+
    254e:	35 91       	lpm	r19, Z+
    2550:	45 91       	lpm	r20, Z+
    2552:	55 91       	lpm	r21, Z+
    2554:	a6 f3       	brts	.-24     	; 0x253e <__fp_powser+0x16>
    2556:	ef 01       	movw	r28, r30
    2558:	0e 94 92 0f 	call	0x1f24	; 0x1f24 <__addsf3x>
    255c:	fe 01       	movw	r30, r28
    255e:	97 01       	movw	r18, r14
    2560:	a8 01       	movw	r20, r16
    2562:	da 94       	dec	r13
    2564:	69 f7       	brne	.-38     	; 0x2540 <__fp_powser+0x18>
    2566:	df 90       	pop	r13
    2568:	ef 90       	pop	r14
    256a:	ff 90       	pop	r15
    256c:	0f 91       	pop	r16
    256e:	1f 91       	pop	r17
    2570:	cf 91       	pop	r28
    2572:	df 91       	pop	r29
    2574:	08 95       	ret

00002576 <inverse>:
    2576:	9b 01       	movw	r18, r22
    2578:	ac 01       	movw	r20, r24
    257a:	60 e0       	ldi	r22, 0x00	; 0
    257c:	70 e0       	ldi	r23, 0x00	; 0
    257e:	80 e8       	ldi	r24, 0x80	; 128
    2580:	9f e3       	ldi	r25, 0x3F	; 63
    2582:	0c 94 ec 0f 	jmp	0x1fd8	; 0x1fd8 <__divsf3>
    2586:	0c 94 32 11 	jmp	0x2264	; 0x2264 <__fp_inf>
    258a:	0c 94 81 13 	jmp	0x2702	; 0x2702 <__fp_mpack>

0000258e <ldexp>:
    258e:	0e 94 72 11 	call	0x22e4	; 0x22e4 <__fp_splitA>
    2592:	d8 f3       	brcs	.-10     	; 0x258a <inverse+0x14>
    2594:	99 23       	and	r25, r25
    2596:	c9 f3       	breq	.-14     	; 0x258a <inverse+0x14>
    2598:	94 0f       	add	r25, r20
    259a:	51 1d       	adc	r21, r1
    259c:	a3 f3       	brvs	.-24     	; 0x2586 <inverse+0x10>
    259e:	91 50       	subi	r25, 0x01	; 1
    25a0:	50 40       	sbci	r21, 0x00	; 0
    25a2:	94 f0       	brlt	.+36     	; 0x25c8 <ldexp+0x3a>
    25a4:	59 f0       	breq	.+22     	; 0x25bc <ldexp+0x2e>
    25a6:	88 23       	and	r24, r24
    25a8:	32 f0       	brmi	.+12     	; 0x25b6 <ldexp+0x28>
    25aa:	66 0f       	add	r22, r22
    25ac:	77 1f       	adc	r23, r23
    25ae:	88 1f       	adc	r24, r24
    25b0:	91 50       	subi	r25, 0x01	; 1
    25b2:	50 40       	sbci	r21, 0x00	; 0
    25b4:	c1 f7       	brne	.-16     	; 0x25a6 <ldexp+0x18>
    25b6:	9e 3f       	cpi	r25, 0xFE	; 254
    25b8:	51 05       	cpc	r21, r1
    25ba:	2c f7       	brge	.-54     	; 0x2586 <inverse+0x10>
    25bc:	88 0f       	add	r24, r24
    25be:	91 1d       	adc	r25, r1
    25c0:	96 95       	lsr	r25
    25c2:	87 95       	ror	r24
    25c4:	97 f9       	bld	r25, 7
    25c6:	08 95       	ret
    25c8:	5f 3f       	cpi	r21, 0xFF	; 255
    25ca:	ac f0       	brlt	.+42     	; 0x25f6 <ldexp+0x68>
    25cc:	98 3e       	cpi	r25, 0xE8	; 232
    25ce:	9c f0       	brlt	.+38     	; 0x25f6 <ldexp+0x68>
    25d0:	bb 27       	eor	r27, r27
    25d2:	86 95       	lsr	r24
    25d4:	77 95       	ror	r23
    25d6:	67 95       	ror	r22
    25d8:	b7 95       	ror	r27
    25da:	08 f4       	brcc	.+2      	; 0x25de <ldexp+0x50>
    25dc:	b1 60       	ori	r27, 0x01	; 1
    25de:	93 95       	inc	r25
    25e0:	c1 f7       	brne	.-16     	; 0x25d2 <ldexp+0x44>
    25e2:	bb 0f       	add	r27, r27
    25e4:	58 f7       	brcc	.-42     	; 0x25bc <ldexp+0x2e>
    25e6:	11 f4       	brne	.+4      	; 0x25ec <ldexp+0x5e>
    25e8:	60 ff       	sbrs	r22, 0
    25ea:	e8 cf       	rjmp	.-48     	; 0x25bc <ldexp+0x2e>
    25ec:	6f 5f       	subi	r22, 0xFF	; 255
    25ee:	7f 4f       	sbci	r23, 0xFF	; 255
    25f0:	8f 4f       	sbci	r24, 0xFF	; 255
    25f2:	9f 4f       	sbci	r25, 0xFF	; 255
    25f4:	e3 cf       	rjmp	.-58     	; 0x25bc <ldexp+0x2e>
    25f6:	0c 94 8d 11 	jmp	0x231a	; 0x231a <__fp_szero>
    25fa:	16 f0       	brts	.+4      	; 0x2600 <ldexp+0x72>
    25fc:	0c 94 81 13 	jmp	0x2702	; 0x2702 <__fp_mpack>
    2600:	0c 94 38 11 	jmp	0x2270	; 0x2270 <__fp_nan>
    2604:	68 94       	set
    2606:	0c 94 32 11 	jmp	0x2264	; 0x2264 <__fp_inf>

0000260a <log>:
    260a:	0e 94 72 11 	call	0x22e4	; 0x22e4 <__fp_splitA>
    260e:	a8 f3       	brcs	.-22     	; 0x25fa <ldexp+0x6c>
    2610:	99 23       	and	r25, r25
    2612:	c1 f3       	breq	.-16     	; 0x2604 <ldexp+0x76>
    2614:	ae f3       	brts	.-22     	; 0x2600 <ldexp+0x72>
    2616:	df 93       	push	r29
    2618:	cf 93       	push	r28
    261a:	1f 93       	push	r17
    261c:	0f 93       	push	r16
    261e:	ff 92       	push	r15
    2620:	c9 2f       	mov	r28, r25
    2622:	dd 27       	eor	r29, r29
    2624:	88 23       	and	r24, r24
    2626:	2a f0       	brmi	.+10     	; 0x2632 <log+0x28>
    2628:	21 97       	sbiw	r28, 0x01	; 1
    262a:	66 0f       	add	r22, r22
    262c:	77 1f       	adc	r23, r23
    262e:	88 1f       	adc	r24, r24
    2630:	da f7       	brpl	.-10     	; 0x2628 <log+0x1e>
    2632:	20 e0       	ldi	r18, 0x00	; 0
    2634:	30 e0       	ldi	r19, 0x00	; 0
    2636:	40 e8       	ldi	r20, 0x80	; 128
    2638:	5f eb       	ldi	r21, 0xBF	; 191
    263a:	9f e3       	ldi	r25, 0x3F	; 63
    263c:	88 39       	cpi	r24, 0x98	; 152
    263e:	20 f0       	brcs	.+8      	; 0x2648 <log+0x3e>
    2640:	80 3e       	cpi	r24, 0xE0	; 224
    2642:	38 f0       	brcs	.+14     	; 0x2652 <log+0x48>
    2644:	21 96       	adiw	r28, 0x01	; 1
    2646:	8f 77       	andi	r24, 0x7F	; 127
    2648:	0e 94 7b 0f 	call	0x1ef6	; 0x1ef6 <__addsf3>
    264c:	e0 e9       	ldi	r30, 0x90	; 144
    264e:	f0 e0       	ldi	r31, 0x00	; 0
    2650:	04 c0       	rjmp	.+8      	; 0x265a <log+0x50>
    2652:	0e 94 7b 0f 	call	0x1ef6	; 0x1ef6 <__addsf3>
    2656:	ed eb       	ldi	r30, 0xBD	; 189
    2658:	f0 e0       	ldi	r31, 0x00	; 0
    265a:	0e 94 94 12 	call	0x2528	; 0x2528 <__fp_powser>
    265e:	8b 01       	movw	r16, r22
    2660:	be 01       	movw	r22, r28
    2662:	ec 01       	movw	r28, r24
    2664:	fb 2e       	mov	r15, r27
    2666:	6f 57       	subi	r22, 0x7F	; 127
    2668:	71 09       	sbc	r23, r1
    266a:	75 95       	asr	r23
    266c:	77 1f       	adc	r23, r23
    266e:	88 0b       	sbc	r24, r24
    2670:	99 0b       	sbc	r25, r25
    2672:	0e 94 95 10 	call	0x212a	; 0x212a <__floatsisf>
    2676:	28 e1       	ldi	r18, 0x18	; 24
    2678:	32 e7       	ldi	r19, 0x72	; 114
    267a:	41 e3       	ldi	r20, 0x31	; 49
    267c:	5f e3       	ldi	r21, 0x3F	; 63
    267e:	0e 94 ab 11 	call	0x2356	; 0x2356 <__mulsf3x>
    2682:	af 2d       	mov	r26, r15
    2684:	98 01       	movw	r18, r16
    2686:	ae 01       	movw	r20, r28
    2688:	ff 90       	pop	r15
    268a:	0f 91       	pop	r16
    268c:	1f 91       	pop	r17
    268e:	cf 91       	pop	r28
    2690:	df 91       	pop	r29
    2692:	0e 94 92 0f 	call	0x1f24	; 0x1f24 <__addsf3x>
    2696:	0c 94 59 11 	jmp	0x22b2	; 0x22b2 <__fp_round>

0000269a <modf>:
    269a:	fa 01       	movw	r30, r20
    269c:	dc 01       	movw	r26, r24
    269e:	aa 0f       	add	r26, r26
    26a0:	bb 1f       	adc	r27, r27
    26a2:	9b 01       	movw	r18, r22
    26a4:	ac 01       	movw	r20, r24
    26a6:	bf 57       	subi	r27, 0x7F	; 127
    26a8:	28 f4       	brcc	.+10     	; 0x26b4 <modf+0x1a>
    26aa:	22 27       	eor	r18, r18
    26ac:	33 27       	eor	r19, r19
    26ae:	44 27       	eor	r20, r20
    26b0:	50 78       	andi	r21, 0x80	; 128
    26b2:	20 c0       	rjmp	.+64     	; 0x26f4 <modf+0x5a>
    26b4:	b7 51       	subi	r27, 0x17	; 23
    26b6:	90 f4       	brcc	.+36     	; 0x26dc <modf+0x42>
    26b8:	ab 2f       	mov	r26, r27
    26ba:	00 24       	eor	r0, r0
    26bc:	46 95       	lsr	r20
    26be:	37 95       	ror	r19
    26c0:	27 95       	ror	r18
    26c2:	01 1c       	adc	r0, r1
    26c4:	a3 95       	inc	r26
    26c6:	d2 f3       	brmi	.-12     	; 0x26bc <modf+0x22>
    26c8:	00 20       	and	r0, r0
    26ca:	71 f0       	breq	.+28     	; 0x26e8 <modf+0x4e>
    26cc:	22 0f       	add	r18, r18
    26ce:	33 1f       	adc	r19, r19
    26d0:	44 1f       	adc	r20, r20
    26d2:	b3 95       	inc	r27
    26d4:	da f3       	brmi	.-10     	; 0x26cc <modf+0x32>
    26d6:	0e d0       	rcall	.+28     	; 0x26f4 <modf+0x5a>
    26d8:	0c 94 7a 0f 	jmp	0x1ef4	; 0x1ef4 <__subsf3>
    26dc:	61 30       	cpi	r22, 0x01	; 1
    26de:	71 05       	cpc	r23, r1
    26e0:	a0 e8       	ldi	r26, 0x80	; 128
    26e2:	8a 07       	cpc	r24, r26
    26e4:	b9 46       	sbci	r27, 0x69	; 105
    26e6:	30 f4       	brcc	.+12     	; 0x26f4 <modf+0x5a>
    26e8:	9b 01       	movw	r18, r22
    26ea:	ac 01       	movw	r20, r24
    26ec:	66 27       	eor	r22, r22
    26ee:	77 27       	eor	r23, r23
    26f0:	88 27       	eor	r24, r24
    26f2:	90 78       	andi	r25, 0x80	; 128
    26f4:	30 96       	adiw	r30, 0x00	; 0
    26f6:	21 f0       	breq	.+8      	; 0x2700 <modf+0x66>
    26f8:	20 83       	st	Z, r18
    26fa:	31 83       	std	Z+1, r19	; 0x01
    26fc:	42 83       	std	Z+2, r20	; 0x02
    26fe:	53 83       	std	Z+3, r21	; 0x03
    2700:	08 95       	ret

00002702 <__fp_mpack>:
    2702:	9f 3f       	cpi	r25, 0xFF	; 255
    2704:	31 f0       	breq	.+12     	; 0x2712 <__fp_mpack_finite+0xc>

00002706 <__fp_mpack_finite>:
    2706:	91 50       	subi	r25, 0x01	; 1
    2708:	20 f4       	brcc	.+8      	; 0x2712 <__fp_mpack_finite+0xc>
    270a:	87 95       	ror	r24
    270c:	77 95       	ror	r23
    270e:	67 95       	ror	r22
    2710:	b7 95       	ror	r27
    2712:	88 0f       	add	r24, r24
    2714:	91 1d       	adc	r25, r1
    2716:	96 95       	lsr	r25
    2718:	87 95       	ror	r24
    271a:	97 f9       	bld	r25, 7
    271c:	08 95       	ret

0000271e <__mulsi3>:
    271e:	db 01       	movw	r26, r22
    2720:	8f 93       	push	r24
    2722:	9f 93       	push	r25
    2724:	0e 94 c1 13 	call	0x2782	; 0x2782 <__muluhisi3>
    2728:	bf 91       	pop	r27
    272a:	af 91       	pop	r26
    272c:	a2 9f       	mul	r26, r18
    272e:	80 0d       	add	r24, r0
    2730:	91 1d       	adc	r25, r1
    2732:	a3 9f       	mul	r26, r19
    2734:	90 0d       	add	r25, r0
    2736:	b2 9f       	mul	r27, r18
    2738:	90 0d       	add	r25, r0
    273a:	11 24       	eor	r1, r1
    273c:	08 95       	ret

0000273e <__udivmodsi4>:
    273e:	a1 e2       	ldi	r26, 0x21	; 33
    2740:	1a 2e       	mov	r1, r26
    2742:	aa 1b       	sub	r26, r26
    2744:	bb 1b       	sub	r27, r27
    2746:	fd 01       	movw	r30, r26
    2748:	0d c0       	rjmp	.+26     	; 0x2764 <__udivmodsi4_ep>

0000274a <__udivmodsi4_loop>:
    274a:	aa 1f       	adc	r26, r26
    274c:	bb 1f       	adc	r27, r27
    274e:	ee 1f       	adc	r30, r30
    2750:	ff 1f       	adc	r31, r31
    2752:	a2 17       	cp	r26, r18
    2754:	b3 07       	cpc	r27, r19
    2756:	e4 07       	cpc	r30, r20
    2758:	f5 07       	cpc	r31, r21
    275a:	20 f0       	brcs	.+8      	; 0x2764 <__udivmodsi4_ep>
    275c:	a2 1b       	sub	r26, r18
    275e:	b3 0b       	sbc	r27, r19
    2760:	e4 0b       	sbc	r30, r20
    2762:	f5 0b       	sbc	r31, r21

00002764 <__udivmodsi4_ep>:
    2764:	66 1f       	adc	r22, r22
    2766:	77 1f       	adc	r23, r23
    2768:	88 1f       	adc	r24, r24
    276a:	99 1f       	adc	r25, r25
    276c:	1a 94       	dec	r1
    276e:	69 f7       	brne	.-38     	; 0x274a <__udivmodsi4_loop>
    2770:	60 95       	com	r22
    2772:	70 95       	com	r23
    2774:	80 95       	com	r24
    2776:	90 95       	com	r25
    2778:	9b 01       	movw	r18, r22
    277a:	ac 01       	movw	r20, r24
    277c:	bd 01       	movw	r22, r26
    277e:	cf 01       	movw	r24, r30
    2780:	08 95       	ret

00002782 <__muluhisi3>:
    2782:	0e 94 5d 15 	call	0x2aba	; 0x2aba <__umulhisi3>
    2786:	a5 9f       	mul	r26, r21
    2788:	90 0d       	add	r25, r0
    278a:	b4 9f       	mul	r27, r20
    278c:	90 0d       	add	r25, r0
    278e:	a4 9f       	mul	r26, r20
    2790:	80 0d       	add	r24, r0
    2792:	91 1d       	adc	r25, r1
    2794:	11 24       	eor	r1, r1
    2796:	08 95       	ret

00002798 <__mulshisi3>:
    2798:	b7 ff       	sbrs	r27, 7
    279a:	0c 94 c1 13 	jmp	0x2782	; 0x2782 <__muluhisi3>

0000279e <__mulohisi3>:
    279e:	0e 94 c1 13 	call	0x2782	; 0x2782 <__muluhisi3>
    27a2:	82 1b       	sub	r24, r18
    27a4:	93 0b       	sbc	r25, r19
    27a6:	08 95       	ret

000027a8 <__muldi3>:
    27a8:	df 93       	push	r29
    27aa:	cf 93       	push	r28
    27ac:	1f 93       	push	r17
    27ae:	0f 93       	push	r16
    27b0:	9a 9d       	mul	r25, r10
    27b2:	f0 2d       	mov	r31, r0
    27b4:	21 9f       	mul	r18, r17
    27b6:	f0 0d       	add	r31, r0
    27b8:	8b 9d       	mul	r24, r11
    27ba:	f0 0d       	add	r31, r0
    27bc:	8a 9d       	mul	r24, r10
    27be:	e0 2d       	mov	r30, r0
    27c0:	f1 0d       	add	r31, r1
    27c2:	03 9f       	mul	r16, r19
    27c4:	f0 0d       	add	r31, r0
    27c6:	02 9f       	mul	r16, r18
    27c8:	e0 0d       	add	r30, r0
    27ca:	f1 1d       	adc	r31, r1
    27cc:	4e 9d       	mul	r20, r14
    27ce:	e0 0d       	add	r30, r0
    27d0:	f1 1d       	adc	r31, r1
    27d2:	5e 9d       	mul	r21, r14
    27d4:	f0 0d       	add	r31, r0
    27d6:	4f 9d       	mul	r20, r15
    27d8:	f0 0d       	add	r31, r0
    27da:	7f 93       	push	r23
    27dc:	6f 93       	push	r22
    27de:	bf 92       	push	r11
    27e0:	af 92       	push	r10
    27e2:	5f 93       	push	r21
    27e4:	4f 93       	push	r20
    27e6:	d5 01       	movw	r26, r10
    27e8:	0e 94 5d 15 	call	0x2aba	; 0x2aba <__umulhisi3>
    27ec:	8b 01       	movw	r16, r22
    27ee:	ac 01       	movw	r20, r24
    27f0:	d7 01       	movw	r26, r14
    27f2:	0e 94 5d 15 	call	0x2aba	; 0x2aba <__umulhisi3>
    27f6:	eb 01       	movw	r28, r22
    27f8:	e8 0f       	add	r30, r24
    27fa:	f9 1f       	adc	r31, r25
    27fc:	d6 01       	movw	r26, r12
    27fe:	0e 94 23 14 	call	0x2846	; 0x2846 <__muldi3_6>
    2802:	2f 91       	pop	r18
    2804:	3f 91       	pop	r19
    2806:	d6 01       	movw	r26, r12
    2808:	0e 94 5d 15 	call	0x2aba	; 0x2aba <__umulhisi3>
    280c:	c6 0f       	add	r28, r22
    280e:	d7 1f       	adc	r29, r23
    2810:	e8 1f       	adc	r30, r24
    2812:	f9 1f       	adc	r31, r25
    2814:	af 91       	pop	r26
    2816:	bf 91       	pop	r27
    2818:	0e 94 23 14 	call	0x2846	; 0x2846 <__muldi3_6>
    281c:	2f 91       	pop	r18
    281e:	3f 91       	pop	r19
    2820:	0e 94 5d 15 	call	0x2aba	; 0x2aba <__umulhisi3>
    2824:	c6 0f       	add	r28, r22
    2826:	d7 1f       	adc	r29, r23
    2828:	e8 1f       	adc	r30, r24
    282a:	f9 1f       	adc	r31, r25
    282c:	d6 01       	movw	r26, r12
    282e:	0e 94 5d 15 	call	0x2aba	; 0x2aba <__umulhisi3>
    2832:	e6 0f       	add	r30, r22
    2834:	f7 1f       	adc	r31, r23
    2836:	98 01       	movw	r18, r16
    2838:	be 01       	movw	r22, r28
    283a:	cf 01       	movw	r24, r30
    283c:	0f 91       	pop	r16
    283e:	1f 91       	pop	r17
    2840:	cf 91       	pop	r28
    2842:	df 91       	pop	r29
    2844:	08 95       	ret

00002846 <__muldi3_6>:
    2846:	0e 94 5d 15 	call	0x2aba	; 0x2aba <__umulhisi3>
    284a:	46 0f       	add	r20, r22
    284c:	57 1f       	adc	r21, r23
    284e:	c8 1f       	adc	r28, r24
    2850:	d9 1f       	adc	r29, r25
    2852:	08 f4       	brcc	.+2      	; 0x2856 <__muldi3_6+0x10>
    2854:	31 96       	adiw	r30, 0x01	; 1
    2856:	08 95       	ret

00002858 <__moddi3>:
    2858:	68 94       	set
    285a:	01 c0       	rjmp	.+2      	; 0x285e <__divdi3_moddi3>

0000285c <__divdi3>:
    285c:	e8 94       	clt

0000285e <__divdi3_moddi3>:
    285e:	f9 2f       	mov	r31, r25
    2860:	f1 2b       	or	r31, r17
    2862:	12 f0       	brmi	.+4      	; 0x2868 <__divdi3_moddi3+0xa>
    2864:	0c 94 60 14 	jmp	0x28c0	; 0x28c0 <__udivdi3_umoddi3>
    2868:	a0 e0       	ldi	r26, 0x00	; 0
    286a:	b0 e0       	ldi	r27, 0x00	; 0
    286c:	ea e3       	ldi	r30, 0x3A	; 58
    286e:	f4 e1       	ldi	r31, 0x14	; 20
    2870:	0c 94 d2 14 	jmp	0x29a4	; 0x29a4 <__prologue_saves__+0xc>
    2874:	09 2e       	mov	r0, r25
    2876:	05 94       	asr	r0
    2878:	22 f4       	brpl	.+8      	; 0x2882 <__divdi3_moddi3+0x24>
    287a:	0e 94 bc 14 	call	0x2978	; 0x2978 <__negdi2>
    287e:	11 23       	and	r17, r17
    2880:	92 f4       	brpl	.+36     	; 0x28a6 <__divdi3_moddi3+0x48>
    2882:	f0 e8       	ldi	r31, 0x80	; 128
    2884:	0f 26       	eor	r0, r31
    2886:	ff ef       	ldi	r31, 0xFF	; 255
    2888:	e0 94       	com	r14
    288a:	f0 94       	com	r15
    288c:	00 95       	com	r16
    288e:	10 95       	com	r17
    2890:	b0 94       	com	r11
    2892:	c0 94       	com	r12
    2894:	d0 94       	com	r13
    2896:	a1 94       	neg	r10
    2898:	bf 0a       	sbc	r11, r31
    289a:	cf 0a       	sbc	r12, r31
    289c:	df 0a       	sbc	r13, r31
    289e:	ef 0a       	sbc	r14, r31
    28a0:	ff 0a       	sbc	r15, r31
    28a2:	0f 0b       	sbc	r16, r31
    28a4:	1f 0b       	sbc	r17, r31
    28a6:	0e 94 6b 14 	call	0x28d6	; 0x28d6 <__udivmod64>
    28aa:	07 fc       	sbrc	r0, 7
    28ac:	0e 94 bc 14 	call	0x2978	; 0x2978 <__negdi2>
    28b0:	cd b7       	in	r28, 0x3d	; 61
    28b2:	de b7       	in	r29, 0x3e	; 62
    28b4:	ec e0       	ldi	r30, 0x0C	; 12
    28b6:	0c 94 ee 14 	jmp	0x29dc	; 0x29dc <__epilogue_restores__+0xc>

000028ba <__umoddi3>:
    28ba:	68 94       	set
    28bc:	01 c0       	rjmp	.+2      	; 0x28c0 <__udivdi3_umoddi3>

000028be <__udivdi3>:
    28be:	e8 94       	clt

000028c0 <__udivdi3_umoddi3>:
    28c0:	8f 92       	push	r8
    28c2:	9f 92       	push	r9
    28c4:	cf 93       	push	r28
    28c6:	df 93       	push	r29
    28c8:	0e 94 6b 14 	call	0x28d6	; 0x28d6 <__udivmod64>
    28cc:	df 91       	pop	r29
    28ce:	cf 91       	pop	r28
    28d0:	9f 90       	pop	r9
    28d2:	8f 90       	pop	r8
    28d4:	08 95       	ret

000028d6 <__udivmod64>:
    28d6:	88 24       	eor	r8, r8
    28d8:	99 24       	eor	r9, r9
    28da:	f4 01       	movw	r30, r8
    28dc:	e4 01       	movw	r28, r8
    28de:	b0 e4       	ldi	r27, 0x40	; 64
    28e0:	9f 93       	push	r25
    28e2:	aa 27       	eor	r26, r26
    28e4:	9a 15       	cp	r25, r10
    28e6:	8b 04       	cpc	r8, r11
    28e8:	9c 04       	cpc	r9, r12
    28ea:	ed 05       	cpc	r30, r13
    28ec:	fe 05       	cpc	r31, r14
    28ee:	cf 05       	cpc	r28, r15
    28f0:	d0 07       	cpc	r29, r16
    28f2:	a1 07       	cpc	r26, r17
    28f4:	98 f4       	brcc	.+38     	; 0x291c <__udivmod64+0x46>
    28f6:	ad 2f       	mov	r26, r29
    28f8:	dc 2f       	mov	r29, r28
    28fa:	cf 2f       	mov	r28, r31
    28fc:	fe 2f       	mov	r31, r30
    28fe:	e9 2d       	mov	r30, r9
    2900:	98 2c       	mov	r9, r8
    2902:	89 2e       	mov	r8, r25
    2904:	98 2f       	mov	r25, r24
    2906:	87 2f       	mov	r24, r23
    2908:	76 2f       	mov	r23, r22
    290a:	65 2f       	mov	r22, r21
    290c:	54 2f       	mov	r21, r20
    290e:	43 2f       	mov	r20, r19
    2910:	32 2f       	mov	r19, r18
    2912:	22 27       	eor	r18, r18
    2914:	b8 50       	subi	r27, 0x08	; 8
    2916:	31 f7       	brne	.-52     	; 0x28e4 <__udivmod64+0xe>
    2918:	bf 91       	pop	r27
    291a:	27 c0       	rjmp	.+78     	; 0x296a <__udivmod64+0x94>
    291c:	1b 2e       	mov	r1, r27
    291e:	bf 91       	pop	r27
    2920:	bb 27       	eor	r27, r27
    2922:	22 0f       	add	r18, r18
    2924:	33 1f       	adc	r19, r19
    2926:	44 1f       	adc	r20, r20
    2928:	55 1f       	adc	r21, r21
    292a:	66 1f       	adc	r22, r22
    292c:	77 1f       	adc	r23, r23
    292e:	88 1f       	adc	r24, r24
    2930:	99 1f       	adc	r25, r25
    2932:	88 1c       	adc	r8, r8
    2934:	99 1c       	adc	r9, r9
    2936:	ee 1f       	adc	r30, r30
    2938:	ff 1f       	adc	r31, r31
    293a:	cc 1f       	adc	r28, r28
    293c:	dd 1f       	adc	r29, r29
    293e:	aa 1f       	adc	r26, r26
    2940:	bb 1f       	adc	r27, r27
    2942:	8a 14       	cp	r8, r10
    2944:	9b 04       	cpc	r9, r11
    2946:	ec 05       	cpc	r30, r12
    2948:	fd 05       	cpc	r31, r13
    294a:	ce 05       	cpc	r28, r14
    294c:	df 05       	cpc	r29, r15
    294e:	a0 07       	cpc	r26, r16
    2950:	b1 07       	cpc	r27, r17
    2952:	48 f0       	brcs	.+18     	; 0x2966 <__udivmod64+0x90>
    2954:	8a 18       	sub	r8, r10
    2956:	9b 08       	sbc	r9, r11
    2958:	ec 09       	sbc	r30, r12
    295a:	fd 09       	sbc	r31, r13
    295c:	ce 09       	sbc	r28, r14
    295e:	df 09       	sbc	r29, r15
    2960:	a0 0b       	sbc	r26, r16
    2962:	b1 0b       	sbc	r27, r17
    2964:	21 60       	ori	r18, 0x01	; 1
    2966:	1a 94       	dec	r1
    2968:	e1 f6       	brne	.-72     	; 0x2922 <__udivmod64+0x4c>
    296a:	2e f4       	brtc	.+10     	; 0x2976 <__udivmod64+0xa0>
    296c:	94 01       	movw	r18, r8
    296e:	af 01       	movw	r20, r30
    2970:	be 01       	movw	r22, r28
    2972:	cd 01       	movw	r24, r26
    2974:	00 0c       	add	r0, r0
    2976:	08 95       	ret

00002978 <__negdi2>:
    2978:	60 95       	com	r22
    297a:	70 95       	com	r23
    297c:	80 95       	com	r24
    297e:	90 95       	com	r25
    2980:	30 95       	com	r19
    2982:	40 95       	com	r20
    2984:	50 95       	com	r21
    2986:	21 95       	neg	r18
    2988:	3f 4f       	sbci	r19, 0xFF	; 255
    298a:	4f 4f       	sbci	r20, 0xFF	; 255
    298c:	5f 4f       	sbci	r21, 0xFF	; 255
    298e:	6f 4f       	sbci	r22, 0xFF	; 255
    2990:	7f 4f       	sbci	r23, 0xFF	; 255
    2992:	8f 4f       	sbci	r24, 0xFF	; 255
    2994:	9f 4f       	sbci	r25, 0xFF	; 255
    2996:	08 95       	ret

00002998 <__prologue_saves__>:
    2998:	2f 92       	push	r2
    299a:	3f 92       	push	r3
    299c:	4f 92       	push	r4
    299e:	5f 92       	push	r5
    29a0:	6f 92       	push	r6
    29a2:	7f 92       	push	r7
    29a4:	8f 92       	push	r8
    29a6:	9f 92       	push	r9
    29a8:	af 92       	push	r10
    29aa:	bf 92       	push	r11
    29ac:	cf 92       	push	r12
    29ae:	df 92       	push	r13
    29b0:	ef 92       	push	r14
    29b2:	ff 92       	push	r15
    29b4:	0f 93       	push	r16
    29b6:	1f 93       	push	r17
    29b8:	cf 93       	push	r28
    29ba:	df 93       	push	r29
    29bc:	cd b7       	in	r28, 0x3d	; 61
    29be:	de b7       	in	r29, 0x3e	; 62
    29c0:	ca 1b       	sub	r28, r26
    29c2:	db 0b       	sbc	r29, r27
    29c4:	0f b6       	in	r0, 0x3f	; 63
    29c6:	f8 94       	cli
    29c8:	de bf       	out	0x3e, r29	; 62
    29ca:	0f be       	out	0x3f, r0	; 63
    29cc:	cd bf       	out	0x3d, r28	; 61
    29ce:	09 94       	ijmp

000029d0 <__epilogue_restores__>:
    29d0:	2a 88       	ldd	r2, Y+18	; 0x12
    29d2:	39 88       	ldd	r3, Y+17	; 0x11
    29d4:	48 88       	ldd	r4, Y+16	; 0x10
    29d6:	5f 84       	ldd	r5, Y+15	; 0x0f
    29d8:	6e 84       	ldd	r6, Y+14	; 0x0e
    29da:	7d 84       	ldd	r7, Y+13	; 0x0d
    29dc:	8c 84       	ldd	r8, Y+12	; 0x0c
    29de:	9b 84       	ldd	r9, Y+11	; 0x0b
    29e0:	aa 84       	ldd	r10, Y+10	; 0x0a
    29e2:	b9 84       	ldd	r11, Y+9	; 0x09
    29e4:	c8 84       	ldd	r12, Y+8	; 0x08
    29e6:	df 80       	ldd	r13, Y+7	; 0x07
    29e8:	ee 80       	ldd	r14, Y+6	; 0x06
    29ea:	fd 80       	ldd	r15, Y+5	; 0x05
    29ec:	0c 81       	ldd	r16, Y+4	; 0x04
    29ee:	1b 81       	ldd	r17, Y+3	; 0x03
    29f0:	aa 81       	ldd	r26, Y+2	; 0x02
    29f2:	b9 81       	ldd	r27, Y+1	; 0x01
    29f4:	ce 0f       	add	r28, r30
    29f6:	d1 1d       	adc	r29, r1
    29f8:	0f b6       	in	r0, 0x3f	; 63
    29fa:	f8 94       	cli
    29fc:	de bf       	out	0x3e, r29	; 62
    29fe:	0f be       	out	0x3f, r0	; 63
    2a00:	cd bf       	out	0x3d, r28	; 61
    2a02:	ed 01       	movw	r28, r26
    2a04:	08 95       	ret

00002a06 <__ashldi3>:
    2a06:	00 2e       	mov	r0, r16
    2a08:	08 30       	cpi	r16, 0x08	; 8
    2a0a:	90 f0       	brcs	.+36     	; 0x2a30 <__ashldi3+0x2a>
    2a0c:	98 2f       	mov	r25, r24
    2a0e:	87 2f       	mov	r24, r23
    2a10:	76 2f       	mov	r23, r22
    2a12:	65 2f       	mov	r22, r21
    2a14:	54 2f       	mov	r21, r20
    2a16:	43 2f       	mov	r20, r19
    2a18:	32 2f       	mov	r19, r18
    2a1a:	22 27       	eor	r18, r18
    2a1c:	08 50       	subi	r16, 0x08	; 8
    2a1e:	f4 cf       	rjmp	.-24     	; 0x2a08 <__ashldi3+0x2>
    2a20:	22 0f       	add	r18, r18
    2a22:	33 1f       	adc	r19, r19
    2a24:	44 1f       	adc	r20, r20
    2a26:	55 1f       	adc	r21, r21
    2a28:	66 1f       	adc	r22, r22
    2a2a:	77 1f       	adc	r23, r23
    2a2c:	88 1f       	adc	r24, r24
    2a2e:	99 1f       	adc	r25, r25
    2a30:	0a 95       	dec	r16
    2a32:	b2 f7       	brpl	.-20     	; 0x2a20 <__ashldi3+0x1a>
    2a34:	00 2d       	mov	r16, r0
    2a36:	08 95       	ret

00002a38 <__ashrdi3>:
    2a38:	97 fd       	sbrc	r25, 7
    2a3a:	10 94       	com	r1

00002a3c <__lshrdi3>:
    2a3c:	00 2e       	mov	r0, r16
    2a3e:	08 30       	cpi	r16, 0x08	; 8
    2a40:	98 f0       	brcs	.+38     	; 0x2a68 <__lshrdi3+0x2c>
    2a42:	08 50       	subi	r16, 0x08	; 8
    2a44:	23 2f       	mov	r18, r19
    2a46:	34 2f       	mov	r19, r20
    2a48:	45 2f       	mov	r20, r21
    2a4a:	56 2f       	mov	r21, r22
    2a4c:	67 2f       	mov	r22, r23
    2a4e:	78 2f       	mov	r23, r24
    2a50:	89 2f       	mov	r24, r25
    2a52:	91 2d       	mov	r25, r1
    2a54:	f4 cf       	rjmp	.-24     	; 0x2a3e <__lshrdi3+0x2>
    2a56:	15 94       	asr	r1
    2a58:	97 95       	ror	r25
    2a5a:	87 95       	ror	r24
    2a5c:	77 95       	ror	r23
    2a5e:	67 95       	ror	r22
    2a60:	57 95       	ror	r21
    2a62:	47 95       	ror	r20
    2a64:	37 95       	ror	r19
    2a66:	27 95       	ror	r18
    2a68:	0a 95       	dec	r16
    2a6a:	aa f7       	brpl	.-22     	; 0x2a56 <__lshrdi3+0x1a>
    2a6c:	11 24       	eor	r1, r1
    2a6e:	00 2d       	mov	r16, r0
    2a70:	08 95       	ret

00002a72 <__adddi3>:
    2a72:	2a 0d       	add	r18, r10
    2a74:	3b 1d       	adc	r19, r11
    2a76:	4c 1d       	adc	r20, r12
    2a78:	5d 1d       	adc	r21, r13
    2a7a:	6e 1d       	adc	r22, r14
    2a7c:	7f 1d       	adc	r23, r15
    2a7e:	80 1f       	adc	r24, r16
    2a80:	91 1f       	adc	r25, r17
    2a82:	08 95       	ret

00002a84 <__subdi3>:
    2a84:	2a 19       	sub	r18, r10
    2a86:	3b 09       	sbc	r19, r11
    2a88:	4c 09       	sbc	r20, r12
    2a8a:	5d 09       	sbc	r21, r13
    2a8c:	6e 09       	sbc	r22, r14
    2a8e:	7f 09       	sbc	r23, r15
    2a90:	80 0b       	sbc	r24, r16
    2a92:	91 0b       	sbc	r25, r17
    2a94:	08 95       	ret

00002a96 <__cmpdi2_s8>:
    2a96:	00 24       	eor	r0, r0
    2a98:	a7 fd       	sbrc	r26, 7
    2a9a:	00 94       	com	r0
    2a9c:	2a 17       	cp	r18, r26
    2a9e:	30 05       	cpc	r19, r0
    2aa0:	40 05       	cpc	r20, r0
    2aa2:	50 05       	cpc	r21, r0
    2aa4:	60 05       	cpc	r22, r0
    2aa6:	70 05       	cpc	r23, r0
    2aa8:	80 05       	cpc	r24, r0
    2aaa:	90 05       	cpc	r25, r0
    2aac:	08 95       	ret

00002aae <__tablejump2__>:
    2aae:	ee 0f       	add	r30, r30
    2ab0:	ff 1f       	adc	r31, r31
    2ab2:	05 90       	lpm	r0, Z+
    2ab4:	f4 91       	lpm	r31, Z
    2ab6:	e0 2d       	mov	r30, r0
    2ab8:	09 94       	ijmp

00002aba <__umulhisi3>:
    2aba:	a2 9f       	mul	r26, r18
    2abc:	b0 01       	movw	r22, r0
    2abe:	b3 9f       	mul	r27, r19
    2ac0:	c0 01       	movw	r24, r0
    2ac2:	a3 9f       	mul	r26, r19
    2ac4:	70 0d       	add	r23, r0
    2ac6:	81 1d       	adc	r24, r1
    2ac8:	11 24       	eor	r1, r1
    2aca:	91 1d       	adc	r25, r1
    2acc:	b2 9f       	mul	r27, r18
    2ace:	70 0d       	add	r23, r0
    2ad0:	81 1d       	adc	r24, r1
    2ad2:	11 24       	eor	r1, r1
    2ad4:	91 1d       	adc	r25, r1
    2ad6:	08 95       	ret

00002ad8 <_exit>:
    2ad8:	f8 94       	cli

00002ada <__stop_program>:
    2ada:	ff cf       	rjmp	.-2      	; 0x2ada <__stop_program>
